DevOps Engineer Roadmap
DevOps Engineer is one of those titles that means something different at every company, but the actual work converges on a consistent core: making it fast and safe for developers to ship code, and making sure what's running in production stays running. That means owning the CI/CD pipelines code travels through, the infrastructure it runs on, and the monitoring that tells you when something breaks before a customer does.
The reason this role commands strong salaries is that it sits at the intersection of two skill sets that are individually common but rarely combined well: software engineering practices, like version control and automation, and systems administration knowledge, like networking, Linux and infrastructure. Someone coming from pure development often knows Git and CI/CD but has to build up Linux and networking depth. Someone coming from sysadmin work usually has the opposite gap. This roadmap is built assuming either starting point and fills in whichever side is missing.
The path goes from Linux and Git as the non-negotiable foundation, through containers and orchestration with Docker and Kubernetes, infrastructure as code with Terraform and Ansible, CI/CD pipelines, and finally the observability, GitOps and incident response practices that define a mature DevOps or SRE-adjacent role rather than someone who can only set up a pipeline once and walk away.
Drag or scroll to explore, click a node to learn more · 10 sections · 27 courses · free and self paced
How to use this roadmap
- 1Don't skip the Linux and networking section even if you're an experienced developer, gaps here are the most common reason DevOps engineers struggle once things break in production.
- 2Sections build on each other in order: containers before Kubernetes, Kubernetes before GitOps, CI/CD before advanced deployment strategies.
- 3Each course expands into concepts, treat them as a checklist of standalone 20 to 30 minute lessons rather than one long course to binge.
- 4Set up a real environment as you go, a local Kubernetes cluster with kind or minikube and a free tier cloud account will teach you more per hour than reading alone.
- 5The observability, GitOps and incident response sections near the end are what separate someone who can deploy an app once from a DevOps engineer a team trusts on call, don't treat them as optional extras.
Linux & Systems Fundamentals
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.
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.
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.
Version Control with Git
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.
Containers with Docker
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.
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.
Container Orchestration with Kubernetes
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.
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.
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.
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.
Infrastructure as Code
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.
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 Pipelines
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.
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.
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.
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.
Cloud Fundamentals
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.
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.
Monitoring & Observability
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.
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.
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.
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
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.
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.
Incident Response & SRE Practices
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.
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.
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.
Not satisfied with the roadmap? Create your own!
Frequently asked questions
DevOps hiring rewards breadth with real depth in a few places, not shallow familiarity with every tool on this list. Working through this roadmap in order, actually running the commands and breaking things in a sandbox environment rather than only reading, is what turns this from a list of tool names into the systems thinking that gets you hired and trusted on call.