Every DevOps tool you will learn runs on something that came before it in this roadmap. Kubernetes runs containers. Docker packages Linux processes. CI/CD pipelines run on Linux servers. If you learn Kubernetes before Docker, or Docker before Linux, you are building on air.
The order in this roadmap is the order that works. Each stage is a dependency for the one after it.
If you are approaching the interview stage, Intervue.io connects you with senior DevOps engineers for one-on-one mock interviews. Real troubleshooting scenarios, specific feedback on your gaps. Visit intervue.io.
Stage 1: Linux and Networking Fundamentals (3 to 4 weeks)
Start here. No exceptions.
Almost every production environment runs on Linux. When a server is unreachable, you diagnose it through a Linux terminal. When a CI/CD pipeline fails on a remote machine, you read Linux logs. When a Kubernetes pod crashes, you exec into a Linux container.
What you need to know: file system navigation and permissions, process management with ps, top, and kill, system services with systemctl, package management with apt or yum, shell scripting in Bash, SSH and remote server access, and basic networking (IP addressing, DNS, ports, HTTP and HTTPS, firewalls with iptables or firewalld).
The networking piece is where most beginners underinvest. Cloud networking is just application networking translated into a cloud context. If you cannot explain what a subnet mask does or trace a failed DNS lookup, you will not be able to diagnose cloud networking issues when they come up on the job or in interviews.
Do not just read about these. Get a Linux VM (VirtualBox, WSL on Windows, or a free AWS EC2 instance) and practice commands until they feel natural. The goal at the end of this stage: be comfortable managing a Linux server from the command line without looking anything up.
Stage 2: Git and Version Control (1 to 2 weeks)
Every DevOps workflow starts with code in a repository. You need to know Git well enough to work in a team environment where multiple people are changing files simultaneously.
What you need: branches, merging versus rebasing, resolving merge conflicts, pull requests, tagging releases, and how CI/CD pipelines get triggered from Git events.
Git is the glue between developer code and everything you will build in the DevOps stages that follow. A pipeline that cannot reliably pull from the right branch is a broken pipeline.
Stage 3: Docker and Containers (3 to 4 weeks)
Docker is the gateway to everything else in modern DevOps. Kubernetes orchestrates Docker containers. CI/CD pipelines build Docker images. Cloud infrastructure often runs Docker containers. You cannot work with the later stages without understanding this one.
What you need: how Docker works (images, containers, the Docker daemon, the client), writing Dockerfiles from scratch, multi-stage builds to keep image sizes small, Docker Compose for running multi-service applications locally, Docker networking, Docker volumes for persistent data, and image registries (Docker Hub, AWS ECR, Google Container Registry).
The practical test: take a simple web application, write a Dockerfile for it, run it as a container, connect it to a database container with Docker Compose, and push the image to a registry. Do this without copying from a tutorial. If you can do it from memory, you know Docker at the right depth.
Multi-stage builds deserve a specific callout. This is the technique for keeping production images small by building in one stage and copying only the compiled output to a minimal runtime image. It comes up in interviews and it matters in production.
Stage 4: CI/CD Pipelines (3 to 4 weeks)
CI/CD is the stage that makes you employable because it is what DevOps engineers actually do at work every day. Building, testing, and deploying code automatically is the core function of the role.
Start with GitHub Actions. It is the most accessible CI/CD tool, uses YAML for pipeline definitions, and runs in GitHub where most projects already live. The concepts you learn here transfer directly to GitLab CI, Jenkins, and AWS CodePipeline.
What you need to know: triggers (on push, on pull request, on schedule), jobs and steps, environment variables and secrets, building a Docker image in a pipeline, running tests automatically, deploying to a server or a cloud environment, and understanding the difference between continuous integration (test on every commit), continuous delivery (deployable on every commit), and continuous deployment (deploy automatically on every commit).
The project that makes this concrete: a pipeline that tests a small application on every pull request, builds a Docker image on merge to main, and deploys the new image to a server or a cloud environment automatically. Building this end to end, not just writing the YAML, is what turns the concept into a skill.
Stage 5: Kubernetes (5 to 7 weeks)
Kubernetes is the longest stage by some distance. Do not start it before Docker is solid.
Kubernetes orchestrates containers across multiple servers. It handles scaling, self-healing, service discovery, and rolling updates. It is expected knowledge for mid-level and above DevOps engineers at product companies and GCCs.
What you need to know: cluster architecture (API server, scheduler, controller manager, etcd, kubelet, kube-proxy), pods, deployments, services, config maps and secrets, persistent volumes and claims, health checks (liveness and readiness probes), namespaces, RBAC for access control, horizontal pod autoscaling, and ingress controllers for external traffic.
Then troubleshooting. This is what interviews test. How do you diagnose a pod stuck in CrashLoopBackOff? What does kubectl describe show you? When do you check kubectl logs versus kubectl events? How do you debug a deployment that is not rolling out?
Start with minikube or kind for a local cluster. Then move to the managed Kubernetes service for your target cloud platform: EKS for AWS, AKS for Azure, GKE for GCP. Managed Kubernetes is how production Kubernetes runs in most companies.
Helm is the package manager for Kubernetes. Know enough to deploy a pre-existing Helm chart and understand what values.yaml does. Senior DevOps engineers write their own Helm charts. For job-readiness, using Helm charts is enough.
Stage 6: Infrastructure as Code with Terraform (3 to 4 weeks)
Manually clicking through cloud consoles is how you learn. Infrastructure as Code (IaC) is how production infrastructure is actually managed.
Terraform is the standard. Platform-agnostic, widely adopted, and the most commonly tested IaC tool in DevOps interviews.
What you need: providers, resources, variables and outputs, state files and what happens when state drifts from reality, terraform plan vs terraform apply, modules for reusable infrastructure, and remote state backends.
The concept that most beginners struggle with: state. Terraform's state file tracks what infrastructure currently exists. If someone manually changes infrastructure outside of Terraform, the state file and reality diverge. Knowing how to detect and resolve this is a real DevOps skill and a common interview question.
Practice by writing Terraform to provision the same infrastructure you built manually: an EC2 instance, an S3 bucket, a VPC with subnets. Then modify it and apply the change. The plan and apply workflow becomes intuitive once you have done it on real infrastructure.
Stage 7: Cloud Platform Fundamentals (3 to 4 weeks, parallel with Stages 3 to 6)
Pick one cloud platform and go deep. AWS has the largest DevOps job market in India. Azure matters in enterprise and Microsoft-ecosystem environments. GCP is worth learning if you are targeting data-heavy or AI-adjacent companies.
For AWS, the services that appear most in DevOps roles: EC2, S3, VPC, IAM, RDS, Elastic Load Balancing, Auto Scaling, Lambda, CloudWatch, and EKS. AWS Certified DevOps Engineer Professional is the most valuable single AWS certification for senior DevOps roles.
The rule that holds across all platforms: five services on one platform understood deeply is better than twenty services across three platforms at surface level. Companies interview on production depth, not breadth.
Stage 8: Monitoring and Observability (2 to 3 weeks)
Deploying infrastructure is half the job. Knowing what is happening in production is the other half.
The standard observability stack: Prometheus for metrics collection, Grafana for visualisation and dashboarding, and an alerting mechanism (Alertmanager for Prometheus, or cloud-native alerting in CloudWatch or Azure Monitor).
For logs: the ELK stack (Elasticsearch, Logstash, Kibana) or EFK (with Fluentd) for log aggregation, search, and analysis. Cloud-native alternatives like AWS CloudWatch Logs and GCP Cloud Logging are also commonly used.
What you need to understand: how to write a Prometheus query (PromQL) to answer a specific operational question, how to build a Grafana dashboard that shows whether an application is healthy, and how to set up an alert that fires when a service is down before the users report it.
Stage 9: Security Basics (2 to 3 weeks)
Security is the area most DevOps engineers underinvest in during learning and that interviewers at financial institutions and security-aware companies probe first.
The concepts relevant to DevOps: IAM least privilege, secrets management (never hardcode credentials, use AWS Secrets Manager, HashiCorp Vault, or Kubernetes secrets), network security groups and VPC security, container security (scanning images for vulnerabilities, running containers as non-root), and supply chain security (signing images, verifying base images).
The interview scenario that tests this: "A developer accidentally committed AWS credentials to a public GitHub repository. Walk me through what you do in the next 15 minutes." If you cannot answer this immediately, security is a gap to close.
What to Build at Each Stage
Projects are what separate job-ready candidates from tutorial completers.
After Linux: configure a Linux server from scratch, set up SSH key authentication, write a Bash script that automates a server backup.
After Docker: containerise a web application with a multi-stage Dockerfile. Run it with Docker Compose alongside a database container. Push the image to Docker Hub.
After CI/CD: a complete pipeline that tests on pull request, builds a Docker image on merge, and deploys automatically to a server.
After Kubernetes: deploy the same application to a local Kubernetes cluster. Add health checks, configure resource limits, set up a readiness probe that prevents traffic until the app is fully started.
After Terraform: provision the infrastructure for your application on AWS using Terraform. Everything from VPC to EC2 to security groups, defined in code.
Before interviews: one complete project on GitHub. A multi-tier application deployed on Kubernetes, provisioned with Terraform, deployed via CI/CD, monitored with Prometheus and Grafana. This is the portfolio piece that makes a DevOps interview concrete.
The Timeline
8 to 12 months from zero for entry-level DevOps roles at IT services companies and mid-tier product companies.
Software engineers transitioning to DevOps: 4 to 6 months. Linux and programming foundations are already there. Docker, Kubernetes, Terraform, and cloud are the additions.
System administrators transitioning to DevOps: 4 to 6 months. Linux and networking are solid. Containers, CI/CD, IaC, and cloud are the additions.
What DevOps Interviews Test
DevOps interviews at product companies and GCCs are scenario-heavy. A pod is stuck in CrashLoopBackOff: walk me through your diagnosis. A CI/CD pipeline is failing at the Docker build step: what do you check first. Design a CI/CD pipeline for a multi-region microservices deployment.
The gap between knowing these things and performing them under interview pressure is real. Explaining your diagnostic reasoning out loud while someone evaluates you is a different skill from debugging alone in your own terminal.
At Intervue.io, DevOps mock interviews are one-on-one with engineers who have operated real production infrastructure and know exactly what these companies look for.
Visit intervue.io to book yours.
FAQs
How long does it take to become a DevOps engineer? 8 to 12 months from zero with consistent work and real projects. Software engineers and sysadmins with relevant backgrounds transition in 4 to 6 months. The variable that matters most is project work: candidates who build real end-to-end pipelines interview better than those who only complete courses.
Should I learn Docker before Kubernetes? Yes, without exception. Kubernetes orchestrates Docker containers. Learning Kubernetes before you understand Docker well is the most common mistake DevOps beginners make. Spend at least 3 weeks with Docker before starting Kubernetes.
Do I need a CS degree to become a DevOps engineer? No. DevOps engineering is one of the most accessible technical roles for career switchers. Linux proficiency, hands-on cloud experience, and a portfolio of projects open most doors. Many successful DevOps engineers came from system administration, networking, or IT operations backgrounds.
What is the most important DevOps certification to get? AWS Certified DevOps Engineer Professional for AWS-focused roles. Certified Kubernetes Administrator (CKA) for Kubernetes-heavy environments. These two together are the strongest pair for Indian product company and GCC DevOps roles.
Is Terraform or Ansible more important for DevOps? Terraform for infrastructure provisioning (creating cloud resources). Ansible for configuration management (configuring software on existing servers). Both appear in enterprise environments. For product company DevOps roles, Terraform is more commonly tested. Learn Terraform first.
I have a DevOps engineer interview coming up. How can I prepare for it? Along with revising DevOps concepts and practicing hands-on scenarios, take a mock interview with a senior DevOps engineer from your target company or a similar company. You'll get a chance to practice real-world troubleshooting questions, understand where you stand, and identify gaps before your actual interview. You can book a one-on-one DevOps mock interview with experienced engineers on Intervue.io.
