Interactive Learning Path

DevOps Engineer Path.

Go from Linux basics to production-grade CI/CD, Infrastructure as Code, containers, Kubernetes, and observability. Structured beginner → intermediate → advanced.

Go from Linux fundamentals to production-grade DevOps engineering. This path is structured into three stages so you build skills in the right order.

Beginner — foundations

Linux & Shell: filesystem, processes, users/permissions, networking, and practical shell scripting.
Git: branching, commits, pull requests, and team collaboration workflows.
Docker (basics): images, containers, volumes, and networking—running and building containerised apps.
GitHub Actions: workflows, jobs, secrets, and artifacts for automated CI.
Terraform (basics): providers, resources, variables, and outputs—the IaC core workflow.
Ansible (basics): inventory, playbooks, modules, idempotency, and roles.

Intermediate — production skills

Docker: Docker Compose, multi-stage builds, and container security.
Kubernetes: pods, deployments, services, and ingress—running apps on a cluster.
GitHub Actions: matrix builds and reusable workflows for team-scale CI.
Terraform: state management, modules, workspaces, and count/for_each.
Ansible: variable precedence, group_vars/host_vars, and Ansible Vault for secrets.
Jenkins: declarative pipelines, multibranch builds, parallel stages, and credentials.
Monitoring: metrics/logs/traces fundamentals, alert design, and Prometheus + Grafana.

Advanced — reliability engineering

Kubernetes: storage/ConfigMaps, DaemonSets/StatefulSets, RBAC, and observability.
Terraform: remote state, safe CI/CD apply, data sources, and GitHub Actions integration.
Ansible: loops, error handling, dynamic inventory, and running Ansible in CI/CD.
GitHub Actions: OIDC keyless auth, deployment environments, approval gates, and rollback.
Jenkins: Shared Libraries for reusable pipeline logic across teams.
Monitoring: OpenTelemetry instrumentation, incident response lifecycle, SLOs, and blameless post-mortems.

Roadmap Curriculum

linux Step 1 of 54

Linux Essentials

Understand Linux’s core concepts—filesystems, processes, users/permissions, and the practical commands you’ll use every day as an engineer.

linux Step 2 of 54

Linux Processes & Troubleshooting

Learn how to inspect running processes, read logs, and debug common issues with practical commands (ps, top, lsof, strace, systemd logs).

linux Step 3 of 54

Linux Users, Groups & Permissions

Learn the Unix permission model: ownership, groups, chmod/chown, and practical patterns for running services safely.

linux Step 4 of 54

Linux Networking Basics

Learn how Linux programs talk to the network: ports, sockets, DNS, routing, and quick debugging with ss, curl, dig, and traceroute.

linux Step 5 of 54

Shell Scripting Patterns for DevOps

Write reliable shell scripts: strict mode, argument parsing, functions, logging, and safe file operations.

git Step 6 of 54

Git Workflow Essentials

Learn the core Git workflow: clone, status, commit, branch, merge, and resolve conflicts safely.

git Step 7 of 54

PR Workflow: From Branch to Merge

Learn a practical pull-request workflow: formatting PRs, handling reviews, resolving conflicts, and choosing merge strategies.

docker Step 8 of 54

Introduction to Docker

What Docker is, why it exists, how containers differ from VMs, and how to install Docker on your machine.

docker Step 9 of 54

Docker Images and Dockerfiles

Pull images from registries, write Dockerfiles, build your own images, and understand layer caching.

docker Step 10 of 54

Managing Docker Containers

Run, inspect, stop, restart, and remove containers. Understand container lifecycle and port mapping.

docker Step 11 of 54

Docker Volumes and Storage

Persist data outside containers using volumes and bind mounts. Understand the container filesystem lifecycle.

docker Step 12 of 54

Docker Networking

Connect containers together, expose services, and understand Docker's built-in network drivers.

github-actions Step 13 of 54

GitHub Actions CI Basics

Get a working GitHub Actions pipeline: triggers, jobs/steps, caching, environment variables, and status checks.

github-actions Step 14 of 54

GitHub Actions: Secrets & Artifacts

Use repository/organization secrets, environments, and artifacts to build and share outputs safely across jobs.

terraform Step 15 of 54

Terraform Fundamentals (IaC)

Understand Terraform’s core workflow: init, validate, plan, apply. Learn state, providers, variables, and modules with practical examples.

terraform Step 16 of 54

Providers and Resources (the building blocks of Terraform)

Learn providers, resources, arguments, attributes, and how Terraform maps configuration to real infrastructure.

terraform Step 17 of 54

Terraform Variables and Outputs

Learn how to parameterize Terraform with input variables and expose values with outputs.

ansible Step 18 of 54

Ansible Fundamentals (Configuration Management)

Learn Ansible’s model: inventory, playbooks, modules, variables, and idempotency. Includes a working ping example and config management pattern.

ansible Step 19 of 54

Ansible Roles (Reusable Configuration Units)

Learn how to structure Ansible code using roles: directory layout, tasks, handlers, templates, defaults, and how to share roles across projects.

docker Step 20 of 54

Docker Compose

Define and run multi-container applications with Docker Compose. Services, networks, volumes, and environment configuration.

docker Step 21 of 54

Multi-Stage Builds

Use multi-stage Dockerfiles to produce small, secure production images by separating build and runtime environments.

docker Step 22 of 54

Docker Security

Harden Docker images and containers: non-root users, read-only filesystems, secrets management, image scanning, and runtime policies.

kubernetes Step 23 of 54

Kubernetes Fundamentals

Learn the core concepts of Kubernetes—clusters, pods, deployments, services, namespaces, and how to reason about orchestration.

kubernetes Step 24 of 54

Pods and Workloads

Understand pods, containers, labels, selectors, and how Kubernetes schedules and manages workload lifecycles.

kubernetes Step 25 of 54

Deployments and Rollouts

Learn how Deployments manage replica sets, rolling updates, rollbacks, and rollout strategies in Kubernetes.

kubernetes Step 26 of 54

Services and Networking

Learn how Services expose Pods reliably using stable virtual IPs, DNS, and service types — with hands-on YAML examples.

kubernetes Step 27 of 54

Kubernetes Services — Hands-On

Hands-on understanding of how Services work: ClusterIP, labels/selectors, Ingress, and service discovery via DNS.

github-actions Step 28 of 54

GitHub Actions: Matrix Builds & Strategy

Run tests across multiple OS, runtime versions, and configurations simultaneously using matrix strategy—reduce feedback time without duplicating workflow YAML.

github-actions Step 29 of 54

GitHub Actions: Reusable Workflows & Composite Actions

Share CI/CD logic across repositories using reusable workflows (workflow_call) and composite actions—avoid duplication without losing flexibility.

terraform Step 30 of 54

Terraform State (tfstate, remote state, locking)

Understand what Terraform state is, why it matters, and how remote state + locking improves safety.

terraform Step 31 of 54

Terraform Modules (reuse, composition, and clean structure)

Learn how Terraform modules package reusable infrastructure patterns. Includes practical module call + outputs example.

terraform Step 32 of 54

Terraform `count` and `for_each` (repeat resources safely)

Learn when to use `count` vs `for_each`, how Terraform addresses multiple instances, and practical examples.

terraform Step 33 of 54

Workspaces and Environments (dev/stage/prod patterns)

Learn Terraform workspaces and recommended environment isolation patterns. Includes examples and safe practices.

ansible Step 34 of 54

Ansible Variables & Vault (Secrets Management)

Master Ansible variable precedence, host_vars, group_vars, and Ansible Vault for encrypting secrets like passwords and API keys.

jenkins Step 35 of 54

Jenkins CI: Pipeline Basics

Learn what Jenkins is and how to use declarative pipelines: stages, agents, steps, and basic CI patterns.

jenkins Step 36 of 54

Jenkins: Credentials & Agents

Use Jenkins credentials without leaking secrets. Control execution using labels/agents and archive artifacts between stages.

jenkins Step 37 of 54

Jenkins: Multibranch Pipelines & Parallel Stages

Level up Jenkins by running builds for every branch automatically, parallelising slow stages, and controlling flow with post conditions and input gates.

monitoring Step 38 of 54

Monitoring & Observability Essentials

Learn the difference between monitoring and observability, core signals (metrics/logs/traces), and how to think in SLOs and actionable alerts.

monitoring Step 39 of 54

Alerting & Runbooks

Design alerts that page the right people at the right time—plus how to attach runbooks so incidents are fixable quickly.

monitoring Step 40 of 54

Prometheus & Grafana: Metrics and Dashboards

Set up Prometheus to scrape metrics and Grafana to visualise them. Learn PromQL basics, recording rules, and how to build actionable dashboards.

kubernetes Step 41 of 54

ConfigMaps, Secrets, and Storage

Learn how Kubernetes separates configuration from images using ConfigMaps/Secrets and how volumes persist data.

kubernetes Step 42 of 54

Workload Controllers

Learn how Kubernetes controllers like Deployments, StatefulSets, DaemonSets, and Jobs maintain desired state and handle reconciliation.

kubernetes Step 43 of 54

Security, RBAC, and Observability

Learn Kubernetes RBAC for access control and how to monitor cluster and workload health with logs, metrics, and events.

docker Step 44 of 54

Docker in Production

Production patterns for Docker: health checks, logging drivers, resource limits, registries, and CI/CD integration.

terraform Step 45 of 54

Terraform Workflow (init → validate → plan → apply)

Learn the Terraform command workflow and what each step guarantees. Includes practical copy/paste examples.

terraform Step 46 of 54

Remote State Safety (locking, drift, and recovery)

Learn safety practices for remote state: locking, drift detection, and recovery strategies when reality changes.

terraform Step 47 of 54

Data Sources and Dependencies (read existing infrastructure)

Learn how Terraform data sources fetch information from providers, and how Terraform resolves dependencies between resources.

terraform Step 48 of 54

Terraform CI/CD with GitHub Actions (plan/apply)

Learn a safe CI/CD workflow for Terraform using GitHub Actions: formatting, validation, plan, and gated apply.

ansible Step 49 of 54

Advanced Ansible Playbook Patterns

Master loops, conditionals, error handling, dynamic inventory, and performance patterns to write production-grade Ansible playbooks.

ansible Step 50 of 54

Ansible in CI/CD Pipelines

Integrate Ansible with GitHub Actions and Jenkins to automate configuration management and application deployments as part of your CI/CD pipeline.

github-actions Step 51 of 54

GitHub Actions: Deployment Workflows & OIDC

Build production-ready deployment pipelines with environment gates, manual approvals, OIDC keyless auth to cloud providers, and rollback strategies.

jenkins Step 52 of 54

Jenkins Shared Libraries

Eliminate copy-pasted Jenkinsfiles by extracting common pipeline logic into a Shared Library—versioned, tested, and available to all team pipelines.

monitoring Step 53 of 54

OpenTelemetry: Unified Observability

Instrument applications with OpenTelemetry to emit traces, metrics, and logs in a vendor-neutral format. Learn the OTel data model, collectors, and backends.

monitoring Step 54 of 54

Incident Management & Post-Mortems

Build a repeatable incident response process: detection, communication, mitigation, and blameless post-mortems that improve reliability over time.