13 - DevOps for Backend Engineers
This track is about the distance between "my service passes its tests" and "my
service is running in production" — the path that CI/CD, containers, and deployment
strategies lay down, seen from the backend engineer's chair. It is deliberately
not a Docker/Kubernetes/Terraform course: the sibling
../../learn/ curriculum already teaches infrastructure
operations in depth. This track teaches the other half — what a backend developer
needs to know and decide so their code containerizes well, survives a rolling
deploy, migrates its database without downtime, and exposes what a platform needs
to manage it — and then points you at the exact learn/ track to go deep in for
each operational concern (e.g. learn/02-docker, learn/03-kubernetes,
learn/06-azure-container-apps, learn/07-aks, learn/10-cicd-and-gitops).
How this track works
- It depends on two earlier tracks and builds directly on them, rather than re-teaching them. From track 08 (Observability and Operational Readiness) it takes the 12-factor methodology (module 10), graceful shutdown (module 09), config and secrets (modules 02-03), and metrics (module 06) — this track puts all of them to work in a container and a deploy. From track 12 (Testing and Code Quality) it picks up exactly where module 07's brief CI section stopped, taking your test pyramid and quality gates and wiring them into a full pipeline.
- Every module answers the same question from the backend side: what does my code
and my app need to do to work well here, and then which
learn/track do I go to for the operational deep-dive. The examples are real Python/FastAPI, Docker, and YAML — but the deep operational mechanics are always cross-referenced, not duplicated. - Every standard module (00-07) has the same shape: why it matters, concepts, a command reference with real code, progressive hands-on exercises (do them — including a "diagnose and fix" scenario each), an independent challenge with no code, common mistakes, and a checkpoint quiz. Two closed-book cumulative reviews sit in module 03 (covering 00-03) and module 07 (covering 00-07). Go in order — each module assumes the ones before it, and the capstone integrates all of them.
- Everything runs locally: Docker for images and backing services (Postgres,
Redis), a CI definition you can reason about or run with
act, and multi-replica runs to feel statelessness and zero-downtime deploys — no cloud account required to learn the concepts (the cloud specifics are the namedlearn/tracks).
Modules
| # | Module | What you'll be able to do | Time |
|---|---|---|---|
| 00 | Containerizing a backend app | Write a production-grade multi-stage Dockerfile for a FastAPI app: slim base, cache-friendly layers, non-root, small image | 60-90 min |
| 01 | The 12-factor app in a container | Make the container config-injected, stateless, and SIGTERM-disposable — the factors a container makes or breaks | 60-90 min |
| 02 | CI pipelines for backend code | Build a two-lane CI pipeline that lints, type-checks, tests against a service container, and builds/scans/pushes a SHA-tagged image | 75-100 min |
| 03 | Deployment strategies | Deploy with rolling/blue-green/canary without dropping traffic — in-flight handling, backward-compatible APIs, migration ordering | 75-100 min |
| 04 | Database migrations in deployment pipelines | Run zero-downtime migrations with expand/contract, batched backfills, lock-safe DDL, and correct ordering vs the rollout | 75-100 min |
| 05 | Service configuration and environments | Manage config across dev/staging/prod, inject secrets safely at deploy time, and decouple release from deploy with feature flags | 60-90 min |
| 06 | Health checks, readiness, and scaling signals | Expose correct liveness/readiness probes and the metrics a scheduler and autoscaler need to manage your app well | 60-90 min |
| 07 | Choosing your deployment target | Choose deliberately between VM, orchestrator, PaaS, and serverless — and map each choice to the learn/ track to go deep in |
60-90 min |
| 08 | Capstone project | Take a FastAPI service to a production-grade image, a CI pipeline, and a deployment runbook covering migrations, health checks, and rollback | 4-6 hrs |
How to work through this
- Go in order. The track has an arc: it starts with the artifact (a good image, a 12-factor container), moves to the pipeline that produces it (CI), then to getting it into production safely (deployment strategies, migrations, config), then to being managed by a platform (health/scaling signals and choosing a target), and closes with a capstone that integrates all of it. Each module builds on the ones before it.
- Take the two cumulative reviews closed-book. They're in module 03 (over modules 00-03) and module 07 (over modules 00-07). If you can't answer something from three modules back, that's a signal to redo that module's exercises, not to reread the prose.
- Attempt every quiz question and the independent challenge before peeking. The "diagnose and fix" exercise in each module is where the real learning is — sit with the broken Dockerfile/pipeline/migration before opening the solution.
- Work it alongside
learn/. Every module tells you whichlearn/track owns the operational depth for its topic. This track makes you a backend engineer who can decide and hand off well; thelearn/tracks make you able to operate what you chose. They're meant to be done roughly in parallel.
Start here → 00-containerizing-a-backend-app/README.md
Back to the master index: ../README.md
Once you've completed this track, the next one is 14-system-design-interview-practice — the final track, which steps up from operating a single service to designing whole systems: capacity estimation, the structured whiteboard session, and classic system-design problems end to end, drawing on everything you've built across tracks 01-13.