DevOps / Platform Engineer — Learning Roadmap
DevOps / Platform Engineer
Learning Roadmap
Final Version — Master the Foundations First
Core Principle
Do not learn tools first. Learn the systems that the tools automate.
Tools change. Platforms change. Cloud providers change. Fundamentals do not.
Understand the System
↓
Learn the Tool
↓
Automate It
↓
Move to the Cloud
↓
Scale It
The Common Mistake
Many engineers start with cloud-first tools before mastering the underlying systems:
• Starting with (wrong order): • Should start with (correct):
• AWS / EKS • Linux
• Terraform • Networking
• Jenkins • Git + Docker
• ArgoCD • Kubernetes
Result of skipping fundamentals: when something breaks, every problem feels
mysterious. Strong engineers understand the foundations and can troubleshoot at
any layer.
Page 1
DevOps / Platform Engineer — Learning Roadmap
Page 2
DevOps / Platform Engineer — Learning Roadmap
Table of Contents
TOC \h \o "1-2"
Page 3
DevOps / Platform Engineer — Learning Roadmap
The Big Picture
Every stage of the roadmap builds on the one before it. Jumping ahead means learning both the
concept and the tool at the same time — twice the work, half the understanding.
Linux
↓
Networking
↓
Git
↓
Bash Scripting
↓
Build Tools (Maven / Gradle)
↓
Docker
↓
CI/CD Concepts
↓
Jenkins
↓
Kubernetes
↓
Security Fundamentals
↓
Terraform
↓
AWS
↓
Monitoring & Observability
↓
GitOps (ArgoCD)
↓
Platform Engineering
Page 4
DevOps / Platform Engineer — Learning Roadmap
1 Linux
Everything in production runs on Linux. Before touching any DevOps tool, become comfortable
working in a Linux environment. Many production incidents are resolved here, before
Kubernetes is ever involved.
Essential Commands
ssh grep find cat less
tail -f journalctl systemctl chmod chown
tar curl wget ps top
ss netstat
Core Concepts to Understand
• Processes & Services • Permissions (chmod/chown)
• Filesystems • Package Management
• Users & Groups • System Logs
Estimated time: 4–6 weeks of daily hands-on practice. Set up a Linux VM. Break
things intentionally. Fix them from the command line.
2 Networking
Networking is one of the most valuable troubleshooting skills in DevOps. Most "Kubernetes
issues" are, in reality, networking or permissions issues.
Concepts to Learn
• DNS • NAT
• TCP/IP • Load Balancers
• HTTP / HTTPS • Reverse Proxies
• TLS / SSL • Subnets
• Ports & Routing • Firewalls
Page 5
DevOps / Platform Engineer — Learning Roadmap
Be Able to Troubleshoot
• Application not reachable • Connection timeouts
• DNS failures • Ingress problems
• SSL certificate issues
Estimated time: 2–3 weeks. Practice with curl, dig, nslookup, tcpdump, and ss. Spin
up a local Nginx reverse proxy.
3 Git
Every deployment starts here. Git is the source of truth for code, configuration, and
infrastructure.
Essential Commands
git clone git add git commit git push
git pull git fetch git merge git rebase
git branch git tag git log git diff
Concepts to Understand
• Branching Strategies • Release Tags
• Pull Requests • Version Control Workflows
• Merge Conflicts • GitFlow vs Trunk-based
Estimated time: 1–2 weeks. Contribute to a project. Intentionally create and resolve
merge conflicts. Practice rebasing.
Page 6
DevOps / Platform Engineer — Learning Roadmap
4 Bash Scripting
Automation without scripting is incomplete. Bash is the glue that connects Linux, Git, Docker,
and CI/CD pipelines. Python is a valuable second language for more complex automation.
Bash Fundamentals
Variables, conditionals, loops
Functions and arguments
Exit codes and error handling
File operations and string manipulation
Cron jobs and scheduled tasks
Piping and redirection
Python for DevOps
• File parsing (JSON, YAML, CSV) • AWS SDK (boto3)
• API interactions (requests) • Kubernetes client library
Estimated time: 2–3 weeks. Write scripts to automate repetitive tasks: log parsing,
file cleanup, health checks, deployment helpers.
5 Build Tools (Maven / Gradle)
Understand how source code becomes deployable software. DevOps engineers are responsible
for the entire pipeline — that includes the build stage.
Source Code
↓
Build Tool (Maven / Gradle)
↓
Artifact (JAR / WAR)
Learn
• Project Structure • Testing Integration
• Dependencies • Packaging
• Build Lifecycle • Artifact Generation
Page 7
DevOps / Platform Engineer — Learning Roadmap
Estimated time: 1 week. Clone a Java project. Run the full build. Inspect the
generated artifact. Understand what each build phase does.
6 Docker
Docker is where application packaging becomes clear. Every modern deployment starts with a
container image. Understand containers deeply before Kubernetes.
Application
↓
Dockerfile
↓
Container Image
↓
Container Registry
Key Concepts
• Dockerfile • Registries (ECR, DockerHub)
• Images & Containers • Multi-stage Builds
• Volumes & Networks • Docker Compose
Essential Commands
docker build docker run docker logs
docker exec docker inspect docker push
docker pull docker ps docker rm
Estimated time: 2–3 weeks. Containerise a real application from scratch. Write multi-
stage Dockerfiles. Use Docker Compose for local development.
Page 8
DevOps / Platform Engineer — Learning Roadmap
7 CI/CD Concepts
Before learning Jenkins, understand what it is orchestrating. CI/CD is a set of practices, not just
a tool.
Core Concepts
• Continuous Integration • Artifact Repositories
• Continuous Delivery • Release Strategies
• Continuous Deployment • Rollback Strategies
Developer Commit
↓
Build
↓
Test
↓
Package
↓
Deploy
Estimated time: 3–5 days. Study the differences between CI, CD (delivery), and CD
(deployment). Understand blue-green, canary, and rolling deployments.
8 Jenkins
Key Insight: Jenkins = Orchestrator. Jenkins connects everything together — Git,
build tools, Docker, and Kubernetes. It does not replace knowledge of those tools; it
requires it.
Learn
• Pipelines (Declarative & Scripted) • Shared Libraries
• Agents & Executors • Webhooks & Triggers
• Credentials Management • Pipeline as Code (Jenkinsfile)
Page 9
DevOps / Platform Engineer — Learning Roadmap
A Typical Jenkins Pipeline
Git Checkout
↓
Build (Maven/Gradle)
↓
Unit Tests
↓
Docker Build
↓
Docker Push (ECR)
↓
Kubernetes Deploy
Estimated time: 2–3 weeks. Build a real pipeline that compiles code, runs tests,
builds a Docker image, and deploys it. Use Jenkinsfile stored in Git.
Page 10
DevOps / Platform Engineer — Learning Roadmap
9 Kubernetes
Kubernetes is the runtime for container workloads at scale. Having Docker knowledge first
means Kubernetes concepts map naturally to what you already understand.
Core Resources
• Pods • ConfigMaps
• Deployments • Secrets
• ReplicaSets • Ingress
• Services • Namespaces
Advanced Topics
• Helm • Network Policies
• StatefulSets • Storage Classes
• DaemonSets • RBAC & Cluster Troubleshooting
Estimated time: 4–6 weeks. Set up a local cluster with minikube or kind. Deploy a
real application. Debug CrashLoopBackOff. Write Helm charts.
10 Security Fundamentals
Security is not a separate discipline — it is part of every DevOps stage. A DevOps engineer
who cannot answer basic security questions is a risk to the systems they manage.
Core Topics
• Linux Security (hardening, sudoers) • IAM Concepts & Least Privilege
• TLS/SSL & Certificate Management • Container Security (image scanning)
• Secrets Management (Vault, AWS SM) • RBAC in Kubernetes
Questions You Should Be Able to Answer
• Who can access what, and why?
• How is authentication done at each layer?
• Where are secrets stored, and who can read them?
Page 11
DevOps / Platform Engineer — Learning Roadmap
• How are container images scanned for vulnerabilities?
• What happens if a secret is committed to Git?
Estimated time: 2–3 weeks. Integrate image scanning into a Jenkins pipeline. Set up
Vault or AWS Secrets Manager. Review your Kubernetes RBAC config.
Page 12
DevOps / Platform Engineer — Learning Roadmap
11 Terraform (Infrastructure as Code)
Terraform turns manual, error-prone infrastructure into version-controlled, repeatable code.
After learning Linux and networking, Terraform concepts will be immediately intuitive.
Manual Infrastructure
↓
Terraform Code (HCL)
↓
Version Controlled Infrastructure
↓
Automated Provisioning
Core Concepts
• Providers • Modules
• Resources • State Management
• Variables & Outputs • Remote Backends (S3 + DynamoDB)
Estimated time: 2–3 weeks. Provision a VPC, EC2 instance, and S3 bucket with
Terraform. Use a remote backend. Write reusable modules.
12 AWS
Cloud services make immediate sense once you understand the underlying technologies. AWS
is simply a managed version of what you already know.
Concept Mapping
Linux Server → EC2
Docker Registry → ECR (Elastic Container Registry)
Kubernetes → EKS (Elastic Kubernetes Service)
Networking → VPC (Virtual Private Cloud)
Permissions → IAM (Identity and Access Management)
Object Storage → S3
Monitoring → CloudWatch
Page 13
DevOps / Platform Engineer — Learning Roadmap
Core Services to Master
• EC2 (compute) • ECR (container registry)
• VPC (networking) • EKS (managed Kubernetes)
• IAM (permissions) • Load Balancers (ALB/NLB)
• S3 (storage) • CloudWatch (monitoring)
Estimated time: 4–6 weeks. Build a production-like environment: VPC with
public/private subnets, an EKS cluster, ECR registry, and ALB. Use Terraform to
provision everything.
Page 14
DevOps / Platform Engineer — Learning Roadmap
13 Monitoring & Observability
Deployment is only half the job. A DevOps engineer who cannot monitor and observe running
systems is working blind.
Build
↓
Deploy
↓
Monitor
↓
Troubleshoot
↓
Improve
Three Pillars of Observability
• Metrics (what is happening now) • Tracing (why it happened)
• Logs (what happened and when) • Alerting & Dashboards
Standard Toolstack
• Prometheus (metrics collection) • Loki (log aggregation)
• Grafana (dashboards & visualisation) • Alertmanager (alert routing)
SLO / SLI Concepts
• SLI — Service Level Indicator: the actual measured metric (e.g. 99.2% uptime)
• SLO — Service Level Objective: the target you commit to (e.g. 99.5% uptime)
• Error Budget — the gap between SLO and 100%; how much failure is acceptable
Estimated time: 2–3 weeks. Deploy Prometheus and Grafana in Kubernetes. Create
dashboards for a real application. Set up an alert that pages on high error rate.
14 GitOps (ArgoCD)
GitOps moves from imperative deployments ("run this command") to declarative deployments
("Git is the truth; make the cluster match it"). ArgoCD enforces this automatically.
Page 15
DevOps / Platform Engineer — Learning Roadmap
Git Repository
↓
Source of Truth
↓
ArgoCD Sync
↓
Kubernetes Cluster
Core Concepts
• Declarative Configuration • GitOps Workflows
• Drift Detection & Auto-Sync • Rollbacks via Git Revert
• Environment Promotion • Multi-cluster Management
Estimated time: 2–3 weeks. Deploy ArgoCD. Set up an application that auto-deploys
from a Git repo. Simulate drift and observe auto-correction.
Page 16
DevOps / Platform Engineer — Learning Roadmap
15 Platform Engineering
Platform Engineering is the next evolution of DevOps. Instead of individual teams managing
their own infrastructure, a platform team builds internal products that make all developers
productive without exposing infrastructure complexity.
Goal: Make developers productive without exposing infrastructure complexity.
Core Concepts
• Internal Developer Platforms (IDPs) • Multi-Cluster Management
• Golden Paths (paved roads for • Platform Automation
developers)
• Self-Service Infrastructure • Developer Experience (DevEx)
Common Toolstack
• Kubernetes (runtime) • Backstage (developer portal)
• ArgoCD (GitOps) • Crossplane (Kubernetes-native IaC)
• Terraform (IaC) • Port / Cortex (service catalogues)
Estimated time: Ongoing. Set up Backstage. Build a self-service workflow for
provisioning a new service. Define golden path templates.
Page 17
DevOps / Platform Engineer — Learning Roadmap
The Complete DevOps Flow
A DevOps / Platform Engineer should be able to explain, operate, and troubleshoot every stage
of this pipeline without relying on tutorials or notes.
Developer Writes Code
↓
Git Repository
↓
Build Tool (Maven / Gradle)
↓
Artifact (JAR / WAR)
↓
Docker Image
↓
Container Registry (ECR)
↓
Jenkins Pipeline
↓
Kubernetes Deployment
↓
Monitoring & Logging (Prometheus / Grafana / Loki)
↓
Cloud Infrastructure (AWS / Terraform)
Career Philosophy
Tools change. Platforms change. Cloud providers change.
Fundamentals do not.
Master Linux, Networking, Git, Docker, and Kubernetes first. Then Jenkins, Terraform, AWS,
ArgoCD, and Platform Engineering become easier because you are learning implementations of
concepts you already understand — not trying to learn both the concept and the tool at the same
time.
Foundation First. Everything Else Builds On Top.
Page 18