Docker Fundamentals Mastery
Never touched a container? Learn Docker the AI-driven way — one tiny image at a time — you write the plain-English brief, the AI writes the Dockerfile, and you end by running your own multi-container app with a single command.
✓ First 2 lessons free · no card needed · one plan unlocks every course
The course at a glance
A from-scratch introduction to Docker for people who have never run a container. No Kubernetes, no cloud account, no terminal anxiety — you install Docker Desktop (or use a free in-browser playground), run one prebuilt image, and watch it spring to life.
Every one of the eleven phases ends in a small thing you actually finish and can run, screenshot or share — a static site in a box, a Dockerized script, a featherweight image, a diary that survives being destroyed — until the final phase, where you wire a web API, a Postgres database and a Redis cache into one Compose file. It is the containers prerequisite for the Senior and Architect career paths.
How learning happens
Every chapter follows the same loop — taught in Phase 0 and run for the rest of the course. Two beats to learn, two beats to build. Most chapters take 30–60 minutes; the build chapter that closes each phase runs longer.
Learn
A short read plus an animated model of the idea. No syntax dumps — you learn what the thing is for.
Brief
Write the instruction in plain English. Precision of intent is the skill being trained here.
Review
Read what came back against a checklist. This is where engineers are actually made.
Tweak
Change one thing yourself, by hand, and watch it move. Ownership beats copy-paste.
What you need first
A computer and curiosity
No ops background, no YAML, no paid tools. If you can install one app and open a terminal, you can start today.
The whole container model
Images, layers, the Dockerfile, volumes, networks, Compose and registries — the real, production-shaped Docker, not a toy subset.
The Senior & Architect paths
Both career paths assume you can already read a Dockerfile and bring up a Compose stack. This quest is how you get there.
The portfolio
Everything built in this course is real, runnable, and shareable — and it compounds into one flagship artefact.
Hello, Container
Your first running container — run it, list it, stop it, remove it, and a screenshot of docker ps showing something you launched.
Nine small images you keep
An image explorer, a static site, a Dockerized script, a featherweight multi-stage build, a persistent diary, a twelve-factor greeter, two networked ships, a Compose file, a pushed registry image — one per phase.
The Full Stack, Composed
A web API, a Postgres database and a Redis cache — three services, one Compose file, persistent data, healthchecks, one command to launch the fleet.
The capstone
Every previous phase taught one piece in isolation. The final phase assembles them into the shape of a real production system — the kind of thing that sits behind every app on your phone — and proves it works by tearing it all down and bringing it back with the data intact.
The Full Stack, Composed
A service from your own image
A small web API built from your own multi-stage Dockerfile, exposing the one port the world needs.
Postgres that remembers
An official Postgres image configured purely from environment variables, on a named volume so the data survives compose down.
A third service by name
A Redis cache the API checks before the database — reached by service name on the Compose-managed network.
One command, whole fleet
Healthchecks and start order fix the "DB not ready" race; docker compose up brings all three services live at once.
Concept coverage matrix
Every major concept, where it's introduced, and where it pays off.
The skill ladder
What you can honestly say after each stage. Each claim maps to something you've built, run, and can show on a screen.
I can run containers and build a first image
A Dockerfile I wrote, built, and opened in my own browser.
I can package real code and keep its data
A slim image that runs anywhere and a container whose data survives being destroyed.
I can configure and connect containers
One image configured three ways, and two containers talking to each other by name.
I can run a real multi-container app
A Compose file that brings up an API, Postgres and Redis with one command.
Time and pacing
Each chapter is roughly 30–45 minutes of focused work plus an hour or two of tinkering; the project chapter that closes each phase runs 60–90 minutes. At a steady two-or-three-chapters-a-week pace this quest lands in about 8–12 weeks — slightly faster than a language course, because Docker has fewer raw concepts but more wiring.
Steady pace
Two or three chapters a week, one mini-project per phase.
Typical chapter
The project chapter closing each phase runs 60–90.
Access
Every phase's Dockerfile, Compose file and runnable result.
One subscription. Every course.
Docker Fundamentals Mastery isn't sold on its own. A single MJ Tech Institute plan unlocks it alongside every other course we've shipped — 8 today, with more added over time — at no extra cost.
Everything, included
Subscribe once and every course unlocks — this one and every future release. No per-course purchases, ever.
Cancel any time
Monthly and annual plans cancel from My account whenever you like. Your progress is always saved.
Start free first
The first 2 lessons of Docker Fundamentals Mastery cost nothing, no card required, before you choose a plan.
Finish with 11 mini-projects and a real multi-container app of your own
Phase 0 is free and takes about an hour. If it doesn't click, you've lost nothing.
Start the course today