Roadmaps › DevOps & Cloud
DevOps Engineer Roadmap
Linux, networking, Git, CI/CD, Docker, Kubernetes, infrastructure as code and monitoring — the skills to ship and run software reliably.
Level: Beginner → Intermediate · Duration: 5–7 months
Step 1: Linux & the terminal
Servers run Linux — live in the terminal.
Almost every server, container and CI runner is Linux. DevOps engineers spend their day in the terminal, so this is the first and most important skill.
- Navigating the file system and editing files
- Users, groups and permissions
- Processes, services and logs
- Bash scripting
Resources: Linux documentation · Linux cheat sheet · ▶ Linux for Beginners
Files, permissions & users
Navigate, chmod, chown, sudo.
Most "it doesn't work on the server" problems are paths and permissions.
- ls, cd, cp, mv, rm, find, grep
- chmod (numeric and symbolic), chown
- sudo and the root user
- Creating users and groups
Processes & services
ps, top, kill, systemd, journalctl.
Know what is running, how much it uses and how to restart it safely.
- ps, top/htop, kill and signals
- systemctl start/stop/enable
- Reading logs with journalctl and tail -f
- Disk and memory: df, du, free
Package managers
apt, dnf, installing and updating software.
Install and update software reproducibly.
- apt (Ubuntu/Debian) and dnf (RHEL/Fedora)
- Adding repositories and keys
- Pinning versions
Shell scripting
Automate tasks with Bash.
Scripts automate repetitive work — backups, deploys, health checks.
- Variables, if, loops and functions
- Exit codes and set -euo pipefail
- Pipes, redirection, xargs
- Scheduling with cron
Resources: Bash documentation
Step 2: Networking basics
Understand how traffic reaches your app.
When a deploy breaks, it is often DNS, ports, TLS or a firewall. Understanding how requests travel makes you fast at debugging.
- IP addresses, ports and protocols
- DNS and HTTP(S)
- Load balancers and reverse proxies
- SSH and firewalls
Resources: Interview questions: Computer Networks
TCP/IP, ports & DNS
What happens between a browser and a server.
Every service listens on a port, and every name is resolved through DNS.
- TCP vs UDP
- Common ports (22, 80, 443, 5432…)
- DNS records (A, CNAME, MX, TXT)
- Tools: ping, curl, dig, ss, traceroute
Resources: Notes: DNS · Notes: Network Devices and Common Ports
HTTP & HTTPS
Status codes, headers, TLS certificates.
APIs and health checks speak HTTP; certificates keep it secure.
- Methods, status codes, headers
- TLS certificates and Let's Encrypt
- Debugging with curl -v
Resources: Notes: HTTP and HTTPS
Load balancers & proxies
Nginx as a reverse proxy.
Nginx sits in front of most apps to terminate TLS and route traffic.
- Reverse proxy configuration
- Load-balancing algorithms
- Health checks and sticky sessions
Resources: Notes: Load Balancing
SSH & firewalls
Key-based login, ufw, security groups.
Secure access to servers is a basic DevOps responsibility.
- SSH keys, ssh-copy-id, ~/.ssh/config
- ufw / iptables basics
- Cloud security groups
- Bastion hosts
Step 3: Git & collaboration
Everything in DevOps starts from a repository.
Code, configuration and infrastructure all live in Git. Pipelines trigger from Git events.
- Daily Git workflow
- Pull requests and reviews
- Branching strategies
- Tags and releases
Resources: Git documentation · Notes: Git and GitHub Essentials · ▶ Complete Git and GitHub Tutorial
Branching & pull requests
Feature branches, code review.
Small branches and reviewed pull requests keep main always deployable.
- Feature branches
- Merge vs rebase
- Resolving conflicts
- Protected branches and required checks
Branching strategies
Trunk-based development vs Git Flow.
Teams agree on how code flows from a laptop to production.
- Trunk-based development
- Git Flow and release branches
- Semantic versioning and tags
Git hooks (optional)
Run checks before commits.
Hooks run scripts automatically — catch problems before they reach CI.
- pre-commit framework
- Lint and format on commit
- Blocking committed secrets
Step 4: Programming for automation
Write scripts and small tools.
DevOps engineers write glue code: scripts, small CLIs and API integrations.
- Python scripting
- Reading and writing YAML/JSON
- Calling REST APIs
- Optional: Go for tooling
Resources: Python documentation
Python scripting
Files, APIs, automation.
Python is the most common language for automation and cloud SDKs (boto3).
- Files and subprocess
- requests for HTTP APIs
- argparse for small CLIs
- boto3 for AWS automation
Go (optional)
Used by Docker, Kubernetes and many DevOps tools.
Docker, Kubernetes, Terraform and Prometheus are written in Go; it compiles to a single binary.
- Syntax, structs and interfaces
- Goroutines and channels
- Building a small CLI
Resources: Go documentation
YAML & JSON
The formats of every config file.
CI pipelines, Kubernetes manifests, Compose files and Ansible all use YAML.
- YAML indentation, lists and maps
- Anchors and multi-document files
- jq and yq for querying
Step 5: Containers with Docker
Package apps so they run the same everywhere.
Containers package an app with its dependencies so it runs the same everywhere. They are the unit of deployment in modern DevOps.
- Running and inspecting containers
- Writing efficient Dockerfiles
- Multi-container apps with Compose
- Pushing images to registries
Resources: Docker documentation · Docker cheat sheet · ▶ Docker, Kubernetes & DevOps Courses
Images & containers
run, ps, logs, exec.
An image is a template; a container is a running instance.
- docker run, ps, logs, exec, stop
- Port mapping and environment variables
- Volumes for persistent data
Dockerfiles
Layers, caching, multi-stage builds.
A good Dockerfile builds fast and produces small, secure images.
- FROM, COPY, RUN, CMD, ENTRYPOINT
- Layer caching order
- Multi-stage builds
- Running as non-root, .dockerignore
Docker Compose
Multi-container apps locally.
Compose runs an app, its database and cache together with one command.
- Services, networks and volumes
- depends_on and health checks
- Environment files
Registries
Docker Hub, GHCR, ECR.
Registries store images so servers and clusters can pull them.
- Docker Hub, GHCR, AWS ECR
- Tagging strategy (git SHA, semver)
- Image scanning
Step 6: CI/CD pipelines
Build, test and deploy automatically on every push.
Continuous integration tests every change; continuous delivery deploys it automatically. This is the heart of DevOps.
- Pipeline as code
- Automated tests and checks
- Safe deployment strategies
- Secrets in pipelines
Resources: GitHub Actions docs · ▶ DevOps Zero to Hero
GitHub Actions
Workflows, jobs, secrets.
GitHub Actions runs workflows on push, pull request or schedule.
- Workflows, jobs, steps and runners
- Caching dependencies
- Matrix builds
- Secrets and environments
Testing & quality gates
Unit tests, linting, scans in the pipeline.
Pipelines should stop bad code before it reaches production.
- Unit and integration tests in CI
- Linting and formatting
- Dependency and image scans
- Required status checks
Deployment strategies
Rolling, blue-green, canary.
Release without downtime and roll back quickly when something goes wrong.
- Rolling updates
- Blue-green deployments
- Canary releases and feature flags
- Automatic rollback
Jenkins / GitLab CI (optional)
Common in companies.
Many companies still run Jenkins or GitLab CI; the concepts are the same.
- Jenkinsfile pipelines
- .gitlab-ci.yml stages
- Self-hosted runners and agents
Step 7: Kubernetes
Run containers at scale.
Kubernetes schedules containers across many machines, heals failures and scales automatically. It is the standard platform at scale.
- Core objects and kubectl
- Configuration and secrets
- Networking and ingress
- Packaging with Helm
Resources: Kubernetes documentation · Kubernetes cheat sheet · ▶ Docker, Kubernetes & DevOps Courses
Pods, Deployments & Services
The core objects.
These three objects run and expose almost every application.
- Pods and their lifecycle
- Deployments, replicas and rolling updates
- Service types (ClusterIP, NodePort, LoadBalancer)
- Probes and resource limits
Config & secrets
ConfigMaps, Secrets, environment.
Keep configuration out of images so the same image runs in every environment.
- ConfigMaps and Secrets
- envFrom and mounted files
- Namespaces per environment
Ingress & scaling
Routing and autoscaling.
Route external traffic and scale with demand.
- Ingress controllers and TLS
- Horizontal Pod Autoscaler
- PersistentVolumeClaims for state
Helm
Package and template apps.
Helm charts template Kubernetes YAML and install apps with one command.
- Installing charts from repositories
- values.yaml overrides
- Writing a simple chart
Step 8: Cloud & infrastructure as code
Create infrastructure from code, not clicks.
Infrastructure as code (IaC) creates servers, networks and databases from versioned files — repeatable and reviewable.
- Core services of one cloud
- Terraform workflow
- State and modules
- Configuration management
Resources: AWS documentation · Cloud Engineer roadmap · ▶ AWS Zero to Hero
One cloud provider
AWS, Azure or GCP basics.
Learn one cloud deeply; the others map closely.
- Compute, storage, networking and IAM
- Managed databases
- Billing alerts
Terraform
Providers, resources, state, modules.
Terraform describes infrastructure in HCL and applies changes safely.
- init, plan, apply, destroy
- Providers, resources and variables
- Remote state and locking
- Modules and workspaces
Resources: Terraform docs
Ansible (optional)
Configuration management.
Ansible configures servers over SSH with YAML playbooks.
- Inventory and playbooks
- Idempotent tasks and roles
Step 9: Monitoring & observability
Know when something breaks — before users tell you.
You can't fix what you can't see. Observability = metrics, logs and traces that tell you what the system is doing.
- Collecting metrics
- Centralised logs
- Meaningful alerts
- Distributed tracing
Metrics
Prometheus and Grafana dashboards.
Prometheus scrapes numbers over time; Grafana shows them on dashboards.
- Counters, gauges, histograms
- The four golden signals: latency, traffic, errors, saturation
- Grafana dashboards
Logs
Centralised logging (Loki, ELK).
Logs from all servers in one searchable place.
- Structured (JSON) logging
- Loki or the ELK stack
- Log retention and cost
Alerts & on-call
SLIs, SLOs, alert fatigue.
Alert on user impact, not on every small blip.
- SLIs, SLOs and error budgets
- Alertmanager / PagerDuty
- Runbooks and post-mortems
Tracing (optional)
OpenTelemetry for distributed systems.
Traces follow one request through many services to find where time is spent.
- Spans and context propagation
- OpenTelemetry
- Jaeger / Tempo
Step 10: Security & reliability
DevSecOps and SRE basics.
DevSecOps puts security into every step; SRE practices keep systems reliable.
- Protecting secrets
- Scanning code, dependencies and images
- Backups and recovery
- A capstone project that ties it all together
Secrets management
Never store secrets in Git.
Leaked credentials are one of the most common causes of breaches.
- Environment variables vs secret stores
- Vault, AWS Secrets Manager, Sealed Secrets
- Rotating keys
Image & dependency scanning
Trivy, Dependabot.
Known vulnerabilities in libraries and base images are easy to find automatically.
- Trivy / Grype scans in CI
- Dependabot / Renovate updates
- Minimal base images
Backups & disaster recovery
Restore drills, multi-zone setups.
A backup you have never restored is not a backup.
- RPO and RTO
- Automated database backups
- Restore drills
- Multi-zone and multi-region setups
Capstone project (optional)
Deploy a MERN app with Docker, CI/CD, Kubernetes and monitoring.
Put it all together: a real app deployed the way companies do it.
- Dockerise a MERN app
- GitHub Actions pipeline with tests
- Deploy to Kubernetes with Helm
- Dashboards and alerts
Resources: MERN roadmap