DevOps Engineer Roadmap 2026 — From Zero to $150K+ in 18 Months

Monday:    Review overnight alerts; write Terraform for new service
Tuesday:   Debug CI/CD pipeline failure with dev team
Wednesday: Kubernetes cluster upgrade in staging
Thursday:  Implement rate limiting in Nginx; write runbook for on-call
Friday:    Cost optimization review; update Grafana dashboards
Weekly:    Capacity planning meeting; incident retrospective
Monthly:   DR drill; security patching; certification study

# Must-know commands
ls -la && cd && pwd && find && grep
chmod 755 && chown && ps aux && kill
systemctl start/stop/status && journalctl -f
ssh -i key.pem user@host && scp && rsync
curl -I && dig && lsof -i :3000
 
# Must-write skills
#!/bin/bash
set -euo pipefail   # Error handling in all scripts
 
for host in web1 web2 web3; do
  ssh ubuntu@$host 'sudo systemctl restart nginx'
done

git log --oneline --graph --all     # Visualize branch history
git rebase -i HEAD~5                # Interactive rebase
git cherry-pick abc123              # Apply specific commits
git bisect start/good/bad           # Binary search for bugs
git stash push -m "WIP"             # Save uncommitted work
git reflog                          # Recover from mistakes

# Production-quality multi-stage Dockerfile
FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json .
RUN npm ci --only=production
 
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json .
RUN npm ci
COPY . .
RUN npm run build
 
FROM node:20-alpine AS runner
RUN addgroup --system --gid 1001 nodejs && \
    adduser --system --uid 1001 nodeuser
WORKDIR /app
COPY --from=deps    /app/node_modules ./node_modules
COPY --from=builder /app/dist        ./dist
USER nodeuser
EXPOSE 3000
CMD ["node", "dist/server.js"]

name: CI/CD
on: [push, pull_request]
 
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20', cache: 'npm' }
      - run: npm ci && npm test
 
  deploy:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - run: echo "Deploy to production"

# Master these K8s concepts in order:
# 1. Pods, Deployments, ReplicaSets
# 2. Services (ClusterIP, NodePort, LoadBalancer)
# 3. ConfigMaps and Secrets
# 4. Ingress with cert-manager for TLS
# 5. RBAC (Roles, ClusterRoles, Bindings)
# 6. HPA (Horizontal Pod Autoscaler)
# 7. PersistentVolumes and PersistentVolumeClaims
# 8. Namespace isolation
# 9. kubectl debug techniques
# 10. Helm charts
 
# Target certification: CKA (Certified Kubernetes Administrator)
# Study: killer.sh practice exams + KodeKloud labs

Three pillars:
1. Metrics  → Prometheus + Grafana (request rate, error rate, latency)
2. Logs     → Grafana Loki (structured JSON with trace IDs)
3. Traces   → OpenTelemetry + Grafana Tempo
 
Key skills:
- Write PromQL queries for dashboards
- Define SLOs: 99.9% uptime, P95 latency below 500ms
- Create alert rules that fire on SLO burn rate

Essential tools:
- SAST:              CodeQL, SonarQube
- Dependency scan:   Snyk, npm audit
- Secrets detection: Gitleaks, TruffleHog
- Container scan:    Trivy
- IaC scan:          checkov, tfsec
- Secrets mgmt:      HashiCorp Vault or AWS Secrets Manager

# ArgoCD Application — Git is the single source of truth
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: myapp
  namespace: argocd
spec:
  source:
    repoURL: https://github.com/myorg/app
    targetRevision: HEAD
    path: k8s/production
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

SRE Toolkit:
- SLIs/SLOs/SLAs    — define and measure reliability
- Error budgets      — "We can have 43.8 min downtime/month at 99.99%"
- Blameless postmortems — learn from incidents, not assign blame
- Chaos engineering  — Chaos Monkey, Litmus Chaos
- Load testing       — k6 or Locust
- On-call rotation   — PagerDuty or OpsGenie

Source Control:  GitHub / GitLab
CI/CD:           GitHub Actions / ArgoCD
Containers:      Docker / Podman
Orchestration:   Kubernetes (EKS / GKE / AKS)
IaC:             Terraform + Pulumi
Config Mgmt:     Ansible
Cloud:           AWS (primary)
Monitoring:      Prometheus + Grafana
Logging:         Grafana Loki
Tracing:         OpenTelemetry + Grafana Tempo
Security:        Vault + Trivy + Gitleaks
Service Mesh:    Istio / Linkerd
GitOps:          ArgoCD / Flux
Developer Portal: Backstage
Cost Visibility: AWS Cost Explorer + Kubecost

Month 1-2:   Linux, Bash, Git, Docker fundamentals + Dockerize personal project
Month 3-4:   GitHub Actions CI/CD, AWS basics, Cloud Practitioner cert
Month 5-6:   Terraform + AWS Solutions Architect Associate cert
Month 7-8:   Kubernetes core, CKA exam preparation
Month 9:     CKA certification + monitoring with Prometheus/Grafana
Month 10:    Ansible, Grafana Loki logging, security scanning in CI
Month 11-12: GitOps with ArgoCD, HashiCorp Vault, DevSecOps pipeline
Month 13-14: Advanced Kubernetes (service mesh, operators, multi-cluster)
Month 15-16: SRE practices, chaos engineering, incident response runbooks
Month 17-18: Platform engineering, Backstage, AWS DevOps Pro cert
 
Portfolio milestones:
- Month 2:  Dockerized app with multi-stage build
- Month 4:  Full CI/CD pipeline: lint + test + Docker + deploy
- Month 6:  Entire AWS stack in Terraform (VPC + ECS + RDS + CloudFront)
- Month 8:  App running on self-managed Kubernetes with Helm
- Month 12: Production-grade stack with full observability (logs/metrics/traces)
- Month 18: Internal developer platform — the senior portfolio piece