Getting everything ready for you…

Loading courses, problems and your progress. This takes just a moment.

0s

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