All roadmaps

Docker

It works on my machine - and everyone else's.

Containers from first principles: images and Dockerfiles, data and networking, Compose for multi-service apps, registries, and the security and production habits that follow.

Your progress0/33 topics · 0%

Progress is saved in this browser.

5 stages33 topics₹0 to follow

Filled nodes are the focus for this track; outlined ones can wait. Tap a topic to open it and mark it done, learning or skipped.

Docker in 2026Related roadmapsDevOps roadmapBackend roadmapNode.js roadmapProve it as you goReading is half of it. This roadmap isbacked by a free, scored Dockercertification with a public verificationlink and a DevOps & Cloud Engineer jobsimulation on real tickets - evidence arecruiter can check, not a claim. Marktopics done, learning or skipped as yougo; your progress carries into theclassic view.Get certified - freeJob simulationClassic viewKnow the demand before thesyntaxDocker in 2026What to learn in 2026Images andcomposeTowardKubernetesAI workloads, containersWhich roles use itEvery engineer,someDevOps andplatformFresher vs switcherWhat companies expectThe hiring barWhat interviewstestProof they verifyWhat gets you hiredA 90-day planProjects thatget readCertification and proofWhat containers are and whythey won.Container FundamentalsContainers vs VMsImages & containersDocker Hub & registriesDockerfiles that build fast andrun small.Building ImagesDockerfile essentialsLayers & cachingMulti-stage buildsReal apps: state, connectivity,many services.Data, Networks & ComposeVolumes & bind mountsNetworkingDocker ComposeContainers you can defend inreview.Production HabitsImage securityResource limits & logsWhere orchestration beginsFresher or experienced?Both tracks hold every topic. On the Fresher track thefoundations are filled and the later stages are outlined - dothem when a project needs them. On the Experienced track thefoundations are outlined and the later stages are filled. The2026 section at the top applies to both.Prefer a list?The classic view shows the same 4 stages as a sequentialchecklist with time estimates. Your marks are shared betweenthe two views.Open the classic view

Everything on this roadmap

Every stage and topic on the map, in reading order. Click any topic to open it.

1.Know the demand before the syntax

2.What containers are and why they won.

3.Dockerfiles that build fast and run small.

4.Real apps: state, connectivity, many services.

5.Containers you can defend in review.

The Docker roadmap, topic by topic

Every topic on the map in reading order, with what to learn and the resources we recommend. Main topics are open; open any subtopic to read it. Select a topic name to open it in the topic panel, where you can track your progress.

  1. 1. Know the demand before the syntax

    Docker in 2026

    2026

    Containers are how software is shipped in 2026: the same image runs on a laptop, in a pipeline and on a cluster, and the cluster is almost always Kubernetes - the CNCF's 2025 survey found 82 percent of container users running it in production, and two thirds of organisations hosting generative AI models using it for inference. Docker is where every engineer learns the container model, and it is the first step on the DevOps path. The four nodes answer what to learn in Docker in 2026, which roles use it, what companies expect and what gets you hired.

    What to learn in 2026

    Learn the container model and the daily tools - images, layers, Dockerfiles, volumes, networks, Compose - then the path toward Kubernetes, and then the 2026 reason containers matter even more: AI workloads, with their models, GPUs and dependencies, ship as images. The sub-nodes order the three.

    Images and compose

    The model first: an image is layers, a container is a process with its own filesystem and network, and the Dockerfile is a build recipe whose order decides cache hits and image size. Then the daily tools - multi-stage builds, volumes for data, networks between containers, environment and secrets, health checks, logs - and Compose to run a whole development stack with one command. Docker is among the most used tools in the Stack Overflow developer survey year after year, and the interview question is always the same: why is this image two gigabytes, and why does it run as root.

    Toward Kubernetes

    Compose runs a stack on one machine; Kubernetes runs it across many, with scheduling, scaling, service discovery, rollouts and self-healing. The CNCF 2025 survey's 82 percent production figure, up from 66 percent in 2023, means a container skill without the next step is half a skill for infrastructure roles. Learn the bridge: image registries, resource limits, health probes, configuration and secrets as objects, and a single service deployed to a small cluster. The DevOps roadmap carries the rest.

    AI workloads, containers

    AI

    AI changed what ships in a container: model weights, GPU drivers, vector databases, inference servers and agent runtimes, each with dependencies that only reproduce inside an image. The CNCF 2025 survey found 66 percent of organisations hosting generative AI models running inference on Kubernetes. For a learner this means two practical skills - building an image for a Python service that calls or serves a model with its dependencies pinned, and knowing what a GPU-enabled container needs - and one habit: assistants write Dockerfiles well and insecurely, so review the base image, the user and the secrets every time.

    Which roles use it

    Every developer uses Docker a little; DevOps, platform and SRE engineers use it all day. The sub-nodes name both groups and lay out the fresher and switcher routes.

    Every engineer, some

    Backend, full stack and data engineers use Docker to run databases locally, to make their service reproducible and to hand it to a pipeline; the Stack Overflow survey's consistent ranking of Docker among the most used tools is these developers. The expectation in those roles is modest and firm: a working Dockerfile and Compose file in every repository, and an image the pipeline can build. Learn that much as part of any engineering path; the Backend and Full Stack roadmaps assume it.

    DevOps and platform

    DevOps, platform and site reliability engineers live in containers: they build the images, the registries, the clusters and the pipelines everyone else uses, and they are judged on image security, size, build time and what happens when a node dies. The CNCF 2025 survey's near-universal Kubernetes adoption defines these roles. For them Docker is the first month and Kubernetes the next six; the DevOps roadmap is the full path and this one its foundation.

    Fresher vs switcher

    A fresher should containerise their own project with a multi-stage Dockerfile, a Compose stack and a pipeline that publishes the image before applying for any engineering role; HackerRank's 2025 report found early-career hiring the hardest hit, and a reproducible repository is a visible differentiator. A switcher from system administration already understands processes and networks and should learn the image model; a switcher from development should learn what happens after the push. On this map freshers get the basics filled and the orchestration stages outlined; experienced learners get the reverse.

    What companies expect

    Companies expect a Dockerfile that builds a small, secure, reproducible image, a Compose file for local development, and an understanding of what runs where when the container reaches a cluster. The sub-nodes cover the bar, the interview and what gets verified.

    The hiring bar

    The bar is a production-grade image: a pinned, minimal base, a multi-stage build, a non-root user, no secrets baked in, a health check, a small final size, and a Compose file that brings up the service with its database in one command. The Work Trend Index found 66 percent of leaders unwilling to hire without AI skills; infrastructure teams expect assistants used to draft Dockerfiles and the engineer accountable for the base image and the user it runs as.

    What interviews test

    Expect to write or fix a Dockerfile live, to explain layers and caching, to debug a container that will not start or cannot reach another, to reduce an image's size, and - for infrastructure roles - to deploy the image to a cluster and explain probes and limits. HackerRank's 2025 report says 66 percent of developers prefer practical assessments and that they are now the standard. The strongest answers explain why: why the build is slow, why the container is root, why the image is large.

    Proof they verify

    Reviewers build your image: a repository where one command runs the stack, a pipeline that has built and pushed the image, a registry tag they can pull, and a readme that states the choices beats any certificate. For infrastructure roles, a cluster with the service deployed and monitored is the proof; the DevOps roadmap's final stage lists the external credentials employers recognise, and OneRoadmap's DevOps certification is free and verifiable.

    What gets you hired

    A repository whose service builds into an image and runs with one command, a pipeline that publishes it, and a deployment a reviewer can see. The sub-nodes give the ninety-day plan, the projects that get read and the proof that counts.

    A 90-day plan

    Month one: the container model, Dockerfiles and Compose on your own project, with the image under a few hundred megabytes and running as a non-root user. Month two: a pipeline that builds, scans and publishes the image, and the service deployed to a small Kubernetes cluster with probes and limits. Month three: an AI service - a model call or a small inference server - containerised with pinned dependencies, monitoring on the cluster, a readme on the choices, and twenty targeted applications a week. The CNCF 2025 survey's 82 percent production Kubernetes figure is why month two ends on a cluster.

    Projects that get read

    Projects that get read are reproducible systems: a web application with a database and a worker brought up by one Compose command and deployed to Kubernetes by a pipeline; an image-size and build-time optimisation with before-and-after numbers; a containerised model-serving endpoint with its dependencies pinned and a cost note. Each has a repository, pipeline history and a readme. The CNCF 2025 survey is the market saying this is how software ships.

    Certification and proof

    Proof is verifiable: a GitHub profile with Dockerfiles and pipelines that have run, an image a reviewer can pull, a deployment they can see, and a short account of your AI workflow. Octoverse 2025 counts more than 180 million developers on GitHub; the ones whose repositories run with one command are the ones who get replies.

  2. 2. What containers are and why they won.

    Container Fundamentals

    What containers are and why they won.

    Time: about 1 week. Topics: Containers vs VMs · Images & containers · Docker Hub & registries.

    Containers vs VMs

    Optional on the Experienced track

    Shared kernel, isolated processes - why containers start in milliseconds and ship everywhere.

    Images & containers

    Optional on the Experienced track

    Immutable images, ephemeral containers and the lifecycle commands (run, stop, rm, logs, exec).

    Docker Hub & registries

    Optional on the Experienced track

    Pulling official images, tags and digests - and reading an image page critically.

  3. 3. Dockerfiles that build fast and run small.

    Building Images

    Dockerfiles that build fast and run small.

    Time: about 1 week. Topics: Dockerfile essentials · Layers & caching · Multi-stage builds.

    Dockerfile essentials

    FROM, COPY, RUN, CMD vs ENTRYPOINT - describing an environment as code.

    Layers & caching

    Order instructions for cache hits; .dockerignore - the difference between 10s and 10min builds.

    Multi-stage builds

    Build heavy, ship light - production images without compilers and dev dependencies.

  4. 4. Real apps: state, connectivity, many services.

    Data, Networks & Compose

    Real apps: state, connectivity, many services.

    Time: about 1-2 weeks. Topics: Volumes & bind mounts · Networking · Docker Compose.

    Build: Compose a full stack. App + database + cache with volumes, health checks and a one-command dev environment.

    Volumes & bind mounts

    Persisting databases and sharing code in dev - data that outlives containers.

    Networking

    Bridge networks, service DNS and port publishing - how containers find each other.

    Docker Compose

    Multi-service stacks with dependencies, env files and health checks - one command for the whole app.

  5. 5. Containers you can defend in review.

    Production Habits

    Containers you can defend in review.

    Time: about 1 week. Topics: Image security · Resource limits & logs · Where orchestration begins.

    Image security

    Optional on the Fresher track

    Non-root users, minimal bases, vulnerability scanning and pinned versions.

    Resource limits & logs

    Optional on the Fresher track

    CPU/memory limits, restart policies and log drivers - containers as good citizens.

    Where orchestration begins

    Optional on the Fresher track

    When Compose stops being enough - the on-ramp to Kubernetes.

Prove it as you go

Reading is half of it. This roadmap is backed by a free, scored Docker certification with a public verification link and a DevOps & Cloud Engineer job simulation on real tickets - evidence a recruiter can check, not a claim. Mark topics done, learning or skipped as you go; your progress carries into the classic view.

Fresher or experienced?

Both tracks hold every topic. On the Fresher track the foundations are filled and the later stages are outlined - do them when a project needs them. On the Experienced track the foundations are outlined and the later stages are filled. The 2026 section at the top applies to both.

Prefer a list?

The classic view shows the same 4 stages as a sequential checklist with time estimates. Your marks are shared between the two views.

Frequently asked questions

What is Docker used for?

Packaging software with its dependencies into an image that runs the same on a laptop, in a pipeline and on a cluster. In 2026 it is how almost everything ships, including the AI workloads - models, GPU drivers, inference servers - whose dependencies only reproduce inside an image. Every developer uses it a little; infrastructure engineers use it all day.

Do I need Docker if I am not a DevOps engineer?

Yes, a working amount: a Dockerfile and a Compose file in every repository, a database run locally in a container, an image the pipeline can build. Backend, full stack and data engineers are expected to have that much. The DevOps roadmap takes it further into clusters and pipelines.

Docker or Kubernetes first?

Docker first. Kubernetes is where containers run at scale, and it only makes sense once the container model - images, layers, volumes, networks, Compose - is understood. The CNCF 2025 survey's 82 percent production Kubernetes figure is why the next step matters; Docker is the step before it.

Why is my image so large or slow to build?

Usually layer order and the base image: dependencies installed before the code is copied so the cache holds, a multi-stage build so the final image carries only the runtime, a minimal pinned base, and a non-root user. These four fixes are also the four interview questions about Docker.

How long does it take to learn Docker?

The container model and the daily tools take a week or two of practice on your own project; a production-grade image with a pipeline that publishes it takes a few weeks more. Nobody can promise a timeline. The evidence is a repository where one command runs the whole stack and an image a reviewer can pull.

Do I need Docker for AI work?

Increasingly, yes. Model weights, GPU drivers, vector databases and agent runtimes ship as images, and the CNCF 2025 survey found two thirds of organisations hosting generative AI models running inference on Kubernetes. Being able to containerise a Python service that calls or serves a model, with dependencies pinned, is now a basic AI engineering skill.

Will AI write my Dockerfiles?

It will draft them well and insecurely: a large base image, a root user, a secret baked into a layer. The review - base image, user, secrets, size, health check - is the skill. Assistants make Docker faster to start and no less necessary to understand.

How do I prove Docker skills without job experience?

A repository where one Compose command brings up the application with its database and worker, a multi-stage Dockerfile under a few hundred megabytes running as non-root, a pipeline that builds, scans and publishes the image, and a deployment to a small Kubernetes cluster. Add an image-size optimisation with before-and-after numbers and a readme on the choices.