How much Docker do you already have?
Be honest — nobody is watching. This only decides which chapters come first; every chapter stays open to you either way.
“I can containerize a working app.”
Start with what a container actually is, then a Dockerfile, then running it — and a small multi-container app with Compose.
- You've run `docker run` off a tutorial without knowing what happened
- You haven't written a Dockerfile from scratch
- You want images, containers and Compose once, in order
“I can ship a real image.”
You can containerize an app. Now learn to do it well: caching, networking, persistence, and the registry/CI workflow that gets it to production.
- Comfortable with a Dockerfile and basic Compose
- You've waited on a slow rebuild or a stale volume and guessed your way past it
- You want an image small and fast enough to actually deploy
“I can reason about the build and the daemon.”
Build caching internals, security hardening, and the orchestration decisions behind a container platform running in production.
- You can already ship a small, cached, non-root image through CI
- You debug slow builds and container security findings, not just "it won't start"
- You want the why under namespaces, cgroups and BuildKit
Not sure? Start at Beginner — every path opens at the section people usually skip.
Full syllabus
Everything each level eventually covers — ticked sections are written, the rest are still on the desk.
Beginner0 / 7 sections written
- What containers arecoming soon
Images vs containers, Docker vs VMs
- Dockerfile basicscoming soon
FROM/COPY/RUN/CMD, building an image
- Running containerscoming soon
docker run, ports, volumes (intro), env vars
- The Docker CLIcoming soon
ps/logs/exec/stop/rm, image management
- .dockerignore & build contextcoming soon
What gets sent to the daemon, and why it's slow without this
- Multi-stage builds (intro)coming soon
Why a build stage shouldn't ship in the final image
- Docker Compose basicscoming soon
Services, one multi-container app
✅ Checkpoint: you can containerize a small app with its own Dockerfile and run it alongside a database using Compose, without copying a tutorial.
Intermediate0 / 8 sections written
- Dockerfile best practicescoming soon
Layer caching, image size, non-root users
- Networkingcoming soon
Bridge networks, container-to-container communication
- Volumes & persistencecoming soon
Named volumes vs bind mounts
- Docker Compose in depthcoming soon
Dependencies, healthchecks, profiles
- Environment-specific configscoming soon
Dev vs prod compose files
- Debugging containerscoming soon
exec, logs, inspecting layers
- Registriescoming soon
Docker Hub, pushing/pulling, tagging strategy
- Docker with CI/CDcoming soon
Building and pushing images in a pipeline
✅ Checkpoint: you can write a cache-efficient, non-root Dockerfile, wire real networking and persistence in Compose, and push a tagged image through CI.
Advanced0 / 7 sections written
- Orchestration basicscoming soon
When you need Kubernetes or Swarm
- Securitycoming soon
Image scanning, least privilege, secrets management
- Build performancecoming soon
BuildKit caching strategies, image layer optimization
- Production Compose / Swarmcoming soon
Compose/Swarm for small production deployments
- Observability for containerscoming soon
Logging drivers, metrics
- Multi-arch buildscoming soon
buildx, ARM vs x86
- Container internalscoming soon
Namespaces, cgroups — what "container" actually means
✅ Checkpoint: you can profile and shrink a slow build, defend a hardening checklist for a production image, and explain when Docker Compose stops being enough.
- Compose shows up in beginner as "run two containers together" and again in intermediate as "run them correctly" — healthchecks and dependency order aren't optional once a real app has a database.
- Registries and CI get their own intermediate chapter because "it works on my machine" usually breaks exactly at the push-an-image step.
- Orchestration (Kubernetes/Swarm) is deliberately kept to "when you need it" — this curriculum teaches Docker deeply, not Kubernetes shallowly.