DevOps Engineer Roadmap

What a DevOps Engineer Actually Does beginner: The real scope of the role, where it overlaps with SRE and platform engineering, and what a typical day looks like.

• DevOps vs SRE vs Platform Engineering: Overlapping but distinct roles focused on reliability and infrastructure.
• The CI/CD to Production Flow: How code moves from a commit to running in front of users.
• Dev and Ops Culture Shift: Why DevOps emerged to break down silos between building and running software.

Linux Fundamentals beginner: The command line, file system and process knowledge that underlies almost every other tool in this roadmap.

• File System Hierarchy: How Linux organizes files, directories and permissions.
• Process Management: Starting, monitoring and killing running programs.
• Shell Scripting Basics: Automating command line tasks with Bash scripts.
• Package Managers: Installing and managing software with apt, yum or similar tools.

Linux Networking Basics beginner: The networking fundamentals that explain why services can or can't reach each other.

• TCP/IP Basics: How data actually travels between two machines on a network.
• DNS: How domain names resolve to IP addresses.
• Ports & Firewalls: Controlling which network traffic is allowed to reach a service.

Git Fundamentals beginner: The version control foundation every CI/CD pipeline and GitOps workflow is built on top of.

• Commits & Branches: The basic units of change and parallel work in Git.
• Merging & Rebasing: Two different ways to combine changes from different branches.
• Pull Requests & Code Review: How teams review and approve changes before merging.

Docker Fundamentals beginner: Packaging an application and its dependencies into a portable, reproducible unit.

• Images & Containers: The blueprint versus the running instance of an application.
• Dockerfile: The instructions that define how a Docker image is built.
• Layers & Caching: How Docker builds images incrementally and speeds up rebuilds.
• Volumes: Persisting data outside a container's own writable layer.

Docker Compose & Container Networking intermediate: Running multi-container applications locally and understanding how containers talk to each other.

• Docker Compose: Defining and running multi-container applications with one config file.
• Container Networking Modes: How containers communicate with each other and the host.
• Multi-Stage Builds: Producing smaller, more secure production images.

Kubernetes Core Concepts intermediate: The building blocks of a Kubernetes cluster, before touching any advanced features.

• Pods: The smallest deployable unit, one or more containers running together.
• Deployments & ReplicaSets: How Kubernetes keeps a desired number of pod replicas running.
• Services: Stable network endpoints that route traffic to a set of pods.
• Namespaces: Logical partitions for organizing resources within a cluster.

Kubernetes Configuration & Storage intermediate: Managing app configuration, secrets and persistent data inside a cluster.

• ConfigMaps & Secrets: Injecting configuration and sensitive values into pods.
• Persistent Volumes: Storage that survives beyond a single pod's lifecycle.
• StatefulSets: Managing pods that need stable identity and storage, like databases.

Kubernetes Networking & Ingress advanced: Getting external traffic into a cluster and routing it to the right service.

• Ingress Controllers: Routing external HTTP traffic to services based on rules.
• Network Policies: Controlling which pods can communicate with each other.
• Service Mesh Basics: Adding traffic control, security and observability between services.

Helm & Kubernetes Package Management advanced: Packaging and templating Kubernetes manifests instead of managing raw YAML everywhere.

• Helm Charts: Reusable, templated bundles of Kubernetes manifests.
• Values Files: Customizing a chart's configuration per environment.
• Chart Repositories: Where Helm charts are published and shared.

Terraform Fundamentals intermediate: Defining cloud infrastructure as versioned, declarative code instead of manual console changes.

• Providers & Resources: How Terraform declares and manages infrastructure across clouds.
• State Management: How Terraform tracks what infrastructure currently exists.
• Variables & Outputs: Parameterizing and exposing values from Terraform configurations.
• Modules: Reusable, shareable Terraform configuration blocks.

Ansible Fundamentals intermediate: Configuring software on servers that already exist, the complement to Terraform's provisioning.

• Playbooks & Tasks: Ansible's declarative files defining configuration steps.
• Inventory: The list of hosts Ansible manages and their groupings.
• Idempotency: Running a playbook repeatedly produces the same end state safely.
• Roles: Reusable, organized bundles of Ansible tasks and configuration.

CI/CD Concepts & Pipeline Design intermediate: The principles behind continuous integration and delivery, before touching any specific tool.

• Continuous Integration: Automatically testing and merging code changes frequently.
• Continuous Delivery vs Deployment: Manually approved releases versus fully automated ones.
• Pipeline Stages: Build, test, and deploy steps a pipeline runs through.

GitHub Actions & GitLab CI intermediate: Building real pipelines with the two most common CI platforms.

• Workflows & Jobs: How GitHub Actions and GitLab CI structure pipeline steps.
• Runners: The machines that actually execute pipeline jobs.
• Secrets Management in CI: Safely storing and using credentials inside pipeline runs.

Jenkins Fundamentals intermediate: The older but still widely deployed self-hosted CI/CD server many enterprises rely on.

• Jenkinsfile & Pipelines as Code: Defining Jenkins pipelines in version controlled code.
• Plugins & Agents: Extending Jenkins and distributing work across build agents.

Deployment Strategies advanced: Shipping changes to production without breaking things for every user at once.

• Blue-Green Deployments: Switching traffic between two identical environments instantly.
• Canary Releases: Rolling a change out to a small percentage of traffic first.
• Rolling Updates: Gradually replacing old instances with new ones.

AWS Core Services intermediate: The cloud services that show up in almost every DevOps job, regardless of which provider a company uses.

• EC2 & Compute: AWS's core virtual machine and compute service.
• VPC & Networking: Isolated virtual networks and how resources connect within them.
• IAM: Controlling who and what can access AWS resources.
• S3 & Storage: AWS's object storage service used across nearly every workload.

Managed Kubernetes & Multi-Cloud Basics advanced: Running Kubernetes on a cloud provider's managed service, and what changes between providers.

• EKS/GKE/AKS: The managed Kubernetes offerings from AWS, GCP and Azure.
• Cloud-Managed Load Balancers: Provider-native load balancing integrated with Kubernetes services.
• Multi-Cloud Tradeoffs: Why and when teams run workloads across more than one cloud.

Metrics with Prometheus intermediate: Collecting and querying the numeric data that tells you a system's real-time health.

• Time Series Metrics: Numeric data points tracked over time, like CPU or request rate.
• PromQL: Prometheus's query language for analyzing collected metrics.
• Exporters: Components that expose a system's metrics for Prometheus to scrape.
• Alertmanager: Routing and deduplicating alerts triggered by metric thresholds.

Dashboards & Visualization with Grafana intermediate: Turning raw metrics into dashboards a human can actually read at a glance during an incident.

• Dashboard Panels: The visual building blocks Grafana dashboards are made of.
• Data Source Integration: Connecting Grafana to Prometheus, Loki and other backends.
• Alerting in Grafana: Configuring alert rules directly from dashboard panels.

Logging with ELK & Loki intermediate: Centralizing logs from every service so you can search them in one place during an incident.

• Elasticsearch, Logstash, Kibana: The classic centralized logging and search stack.
• Grafana Loki: A lighter-weight, Prometheus-inspired log aggregation system.
• Structured Logging: Writing logs in a consistent, machine-parseable format.

Distributed Tracing advanced: Following a single request across multiple microservices to find where it actually slowed down.

• Traces & Spans: How a single request's journey is broken into measurable steps.
• OpenTelemetry: The standard framework for collecting traces, metrics and logs.

GitOps Principles advanced: Making Git the single source of truth for what's actually running in a cluster.

• Declarative Desired State: Describing what infrastructure should look like, not how to get there.
• Git as Source of Truth: Every cluster change traceable to a commit, not a manual action.
• Reconciliation Loops: Continuously syncing actual cluster state to match Git.

ArgoCD & Flux advanced: The two dominant tools for actually implementing GitOps against a Kubernetes cluster.

• ArgoCD Applications: ArgoCD's core resource mapping a Git path to a cluster deployment.
• Flux Sync: How Flux continuously reconciles cluster state from Git.
• Progressive Delivery with GitOps: Combining GitOps with canary or blue-green rollout strategies.

SRE Fundamentals advanced: The reliability engineering concepts that formalize how much downtime is actually acceptable.

• SLIs, SLOs & SLAs: Measuring, targeting and contractually promising reliability levels.
• Error Budgets: The acceptable amount of unreliability before shipping features pauses.
• Toil Reduction: Automating repetitive manual operational work away.

Incident Response advanced: What to actually do in the first ten minutes after something breaks in production.

• On-Call Rotations: How teams share responsibility for responding to incidents.
• Incident Command Roles: Clear responsibilities during an active incident response.
• Runbooks: Documented step-by-step procedures for handling known issues.

Postmortems & Continuous Improvement advanced: Turning an incident into a reason the same failure can't happen the same way twice.

• Blameless Postmortems: Analyzing failures focused on systems, not individual fault.
• Root Cause Analysis: Digging past the surface symptom to the actual underlying cause.