Docker and Containers in Practice: Build, Ship and Run Containers Yourself
Signature Course No. 456 — A Signature AI Socratic Coaching Course.
Built for practitioners who have met containers — your coach starts where you are.
A New Kind of Learning
Socratic coaching, delivered by an agentic AI coach.
Not a course you watch. An AI coach you work with.
The Lighthouse Coach begins by discovering how you think about the subject, teaches what is missing, and gives you realistic practice before asking you to prove that you can use it. You may test out of concepts you already understand, while capstones turn the learning into a practical plan, decision, conversation, or other real-world result.
The curriculum is deliberately authored; the AI delivers it through coaching. It is not an AI randomly generating lessons.
A coach that teaches by asking — not by lecturing
The Lighthouse Coach is an AI Socratic coach built on Cognosco Learning's Docker and Containers in Practice: Build, Ship and Run Containers Yourself course, in the Personal Effectiveness & Well-Being category. It does not play videos at you. It holds a conversation: it asks you a question, listens to your answer, names the misconception it hears, affirms what you got right, and asks the next question — the way a great coach works in the room.
An image is a contract. Most container pain is a contract nobody read. A container is a promise: this software, with these dependencies, in this environment, will behave the same wherever it runs. Keeping that promise is a craft, and this course teaches it at the practitioner's rung — you, building an image, shipping it through a registry, and running it on a host you are responsible for, at Quorline Systems, the running company whose releases, registries, and incidents carry the teaching.
It starts with the line. An image is an artifact — packaged, versioned, identified by a digest that changes whenever its contents change. A container is an instance — a living process started from that image, with its own identity, state, and writable layer. Nearly every expensive container mistake is a line-crossing mistake, and the course returns to that distinction at every step: name the artifact, name the instance, and never let one impersonate the other.
It works in two movements. First, Module 1 — Build and Ship — work through Concepts 1–9, finishing with The Release You Can Prove; then, Module 2 — Run and Operate — work through Concepts 10–18, finishing with The Application You Can Operate.
Both capstones produce real artifacts — a build-and-ship audit of Quorline's dispatch API release 5.0, with its image redesigned, its tags and promotion path specified, its run and data placed, and a one-page release defense an approver can check claim by claim; and a run-and-operate plan for a four-service application under Compose: its declared definition, data and configuration tables, operating policies per service, change choreography with a tested rollback, and an observability and handover design a successor can run for a year.
The honesty standard is part of the course. Dockerfiles appear here as decisions, not syntax drills — you will not find a command reference, because the official documentation does that job and ages faster than any book can. Versions move: Docker, Compose, registries, and scanning tools change their surfaces regularly, so wherever a specific flag, default, or interface matters, the course instructs you to verify the current behavior in the documentation for the version you actually run. And the scope is stated plainly: Compose on hosts you run is the ceiling — no cluster administration is promised or taught.
The course is self-paced and always on — roughly 30 minutes per concept, about 9 hours in full, taken in as many sittings as you like. You can type your answers, or talk out loud: the Voice Coach speaks its questions and listens to your spoken replies. Learners who already know the material can test out concept by concept.
Docker and Containers in Practice: Build, Ship and Run Containers Yourself is part of The Lighthouse Signature Series — the online counterpart to the one-day, in-person learning Cognosco Learning delivers.
Course Facts
One full concept, coached end to end — free: verify your email and we’ll send you a link to start.
Already enrolled? Enter the course →
Diagnose → Learn & Practice → Prove → Capstone
Every learner moves through the same discipline a Cognosco instructor would insist on in the room.
Diagnose
The Coach starts where the course starts: with the line between artifact and instance. Think of the last change you made to running software — did you change the artifact or an instance, and what would happen to that change if the instance were deleted tonight? Say which questions you reach for first when something misbehaves, the image's or the container's; and unpack what two different claims hide inside "the production container is version 2.4.1," and which one a digest can verify. Every concept opens with three questions that locate where you actually stand, and your answers shape how deeply the Coach works the concept with you. Everyone begins with Module 1 — no skipping the foundations you only think you have.
Learn & Practice
Work each concept in conversation with the Coach — spoken or written — then practice it against realistic situations until it holds up.
Prove
Every concept ends in proof: answer the check cold and demonstrate the skill. Know it already? Test out and take credit immediately.
Capstone
Finish with two capstones — The Release You Can Prove for Module 1 and The Application You Can Operate for Module 2 — that pull the whole course together, and earn the certificate.
What You'll Learn
Name the artifact, name the instance — in that order, every time. Every skill in this course is that one distinction at work: build the image deliberately, ship the exact artifact you tested, run the instance as a replaceable thing, and keep what you value — data, configuration, evidence — somewhere a replacement cannot take it.
Module 1 builds and ships. Layers and the cache, where instruction order is money; the base image as a supply-chain decision; small, honest images by multi-stage construction; tags that mean something and a registry promotion path that proves what runs by digest; lifecycle craft; configuration at run time; and data placed to outlive the container.
Module 2 runs and operates. Ports, names, and networks by design; the whole application declared in Compose; the method for hunting why production disagrees with your laptop; health, restarts, and resource limits; security judgment and least privilege; logs, metrics, and seeing inside; updates with a tested way back; performance measured where time actually goes; and day-two housekeeping and handover.
And it holds its boundary throughout. This course assumes you have met the idea of a container before and can work at a command line; it stops well short of cluster administration, on purpose. Its whole territory is the middle rung — build, ship, run, debug, operate — and that territory is where most real production work at small scale actually lives.
What you will learn
- Build images deliberately — layers, cache, and instruction order working for you instead of against you
- Choose base images and write Dockerfiles as a set of judged decisions, keeping images small and honest about their dependencies
- Ship images through a registry under tagging and promotion discipline you can audit
- Run containers well — lifecycle, inspection, logs, and clean shutdown as everyday craft
- Configure containers at run time — environment, files, and secrets handled without baking them into images
- Decide data persistence — volumes, bind mounts, and what must never live in a container's own filesystem
- Connect containers on purpose — ports, names, and networks designed rather than defaulted
- Define and operate a multi-container application with Compose, the ceiling of this course's orchestration
- Apply container security judgment — least privilege, non-root operation, trusted sources, and scanning as a gate
- Operate what you ship — health, resources, updates with rollback, observability, and a debugging method for environment differences
Everything in the course
- All 18 concepts of Docker and Containers in Practice: Build, Ship and Run Containers Yourself, in 2 modules
- A starting-point check first — the Coach finds where you actually stand before teaching
- Learn, Practice, Prove for every concept — no passive video watching
- A test-out on every concept: prove you know it and move on
- The Voice Coach: talk with the Coach out loud — it speaks, listens, and replies
- A personal Learner Record of your work across the course
- Two capstone exercises: The Release You Can Prove and The Application You Can Operate
- A printable session summary whenever you pause
- The Lighthouse Coach completion certificate (Signature Series)
- Your progress is saved as you go — stop anytime, resume where you left off
Developers — who containerize their own services and are tired of images that work by accident, builds that take twenty minutes, and production behavior nobody can explain; and platform and operations engineers at small scale who run containers on hosts or small fleets they own end to end, without a cluster team behind them, and who carry the pager for what they ship.
Technical leads — who set the tagging, registry, and review standards a whole team ships under, and who need those standards to be judgments, not slogans.
Career-switching engineers with some Linux and command-line comfort — who have met containers as a concept and now need the working rung: build, ship, run, debug, operate. This course assumes you can work at a command line, read a simple configuration file, and have seen a container run at least once; it does not assume you have written a Dockerfile you are proud of, run anything in production, or administered any orchestrator — and it will not teach you to administer one.
Prefer to learn live and in person? The same material anchors Cognosco's one-day programs — browse the in-person catalog.
$195 — introductory price. One payment. No subscription, no password to manage.
Here is exactly what happens when you enroll:
- Pay securely with Stripe — you are taken straight into the course
- Create your learner profile and begin the Module 1 starting-point check
- Save the access key you are given — it restores your enrollment on any device
- Learn at your pace; your progress is stored in your browser on your device
For the full voice experience, use Chrome and allow the microphone when asked. Typing your answers works everywhere, all the time. Questions before you enroll? Email hello@cognoscolearning.com.
Before you enroll
What is a Socratic coaching session?
A conversation, not a video. Your coach asks a question; you answer — out loud by voice, or by typing — and the coach responds to what you said: naming the misconception it hears, affirming what you got right, and asking the next question. You advance only when you have mastered each concept, so a finished course means the learning held.
How long does it take — and how long do I have?
About 30 minutes per concept. Learn in sittings of any length; your progress is saved as you go. You have a full year from purchase to finish, and you can revisit and retake within that year.
What does the certificate verify?
That you completed every concept and both capstones of this course. Anyone can confirm a Cognosco certificate online — enter its certificate ID on our verification page.
What if it isn't for me — what are the refunds?
If you have not started, cancel for a full refund within seven days of purchase. Once you have started, there is no cash refund — stop before finishing and we credit the full amount you paid toward any other course in the library (credit valid one year from your original purchase). Once you complete the course, no refund or credit applies.
More Signature Courses are coming
Docker and Containers in Practice: Build, Ship and Run Containers Yourself is Signature Course No. 456. Leave your email and we'll send you news of future Signature Courses and Lighthouse updates as they are announced — nothing else.