The Lighthouse · Signature Series

Containers and Kubernetes: How Modern Software Runs and Ships

Signature Course No. 246 — A Signature AI Socratic Coaching Course.

New

No experience needed — your coach starts where you are.

AI-built course structure. Socratic coaching that builds mastery, not just completion.

An agentic, mastery-based AI learning platform.

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.

Meet The Lighthouse Coach

A coach that teaches by asking — not by lecturing

The Lighthouse Coach is an AI Socratic coach built on Cognosco Learning's Containers and Kubernetes: How Modern Software Runs and Ships 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.

Most software no longer lives the way it used to. Installed once on a named server, tended by hand, and feared whenever a release approached. Modern teams package each service with everything it needs into a portable image, run many isolated copies of it as containers, and hand the whole fleet to an orchestrator that schedules the work, restarts what fails, and rolls out new versions a few copies at a time.

You learn the packaging idea first. Why code alone was never the whole program, what an image freezes and how its digest proves it, what a container isolates and why it is disposable by design — and the honest ledger: density, speed, and portability bought, complexity billed daily, with the cases where a plain server still wins.

Then you learn to judge the running fleet. Declared state and the loop that keeps it, resources priced from measured use, scaling judged by its bottleneck, releases and rollbacks with the way back paved, state and secrets secured, evidence read on one clock, and the exact boundary of what the platform heals.

It works in two movements. First, Module 1 — Packaging the Work: Why Software Stopped Living on Servers — work through Concepts 1–9, finishing with The Container Read; then, Module 2 — Running at Scale Without Losing Sight: Resources, Releases, and the Bad Day — work through Concepts 10–18, finishing with The Platform Decision.

Both capstones produce real artifacts — The Container Read, a clear-eyed account of what Helios Energy runs and how each service should be packaged and declared, with a deliberate non-migration ruled in writing; and The Platform Decision, a rollout and resilience plan for the fleet's hardest afternoon, written for leadership to sign.

The honesty discipline is part of the course. This is a literacy course — principles over click-paths, with no operating commands to memorise and no configuration files to write. It makes no claim that containers are always the answer, and no certification promise: it builds the working model that operational roles assume, framed as durable principles rather than any distribution's current screens.

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.

Containers and Kubernetes: How Modern Software Runs and Ships is part of The Lighthouse Signature Series — the online counterpart to the one-day, in-person learning Cognosco Learning delivers.

Course Facts

Concepts18 · 2 modules
Capstones2
Time per concept≈ 30 minutes
Full course≈ 9 hours, self-paced
FormatOnline · AI voice coach
CertificateOn completion
VerificationVerifiable online
Introductory price$195

One full concept, coached end to end — free: verify your email and we’ll send you a link to start.

AI-built course structure with Socratic coaching that builds mastery, not just completion.

Already enrolled? Enter the course →

The Method

Diagnose → Learn & Practice → Prove → Capstone

Every learner moves through the same discipline a Cognosco instructor would insist on in the room.

1

Diagnose

The Coach starts where the course starts: with what you actually bring. A running program is code plus the environment it silently assumes — and every plan that counts only the code will be ambushed by the other half. 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.

2

Learn & Practice

Work each concept in conversation with the Coach — spoken or written — then practice it against realistic situations until it holds up.

3

Prove

Every concept ends in proof: answer the check cold and demonstrate the skill. Know it already? Test out and take credit immediately.

4

Capstone

Finish with two capstones — The Container Read for Module 1 and The Platform Decision for Module 2 — that pull the whole course together, and earn the certificate.

The Path

From first question to finished work

1

Start where you are

Your coach opens with questions, not a lecture, and finds what you already know. Anything you can already prove, you can test out of — you only study what you have not yet mastered.

2

Learn concept by concept

18 concepts, in two modules, about 30 minutes each, in conversation — you speak or type, the coach responds to what you actually said, and you move on only when the learning holds.

3

Prove it on your own work

You finish with two capstones — The Container Read and The Platform Decision — completed as real work products drawn from your own workplace situation, not a made-up case study.

Module One: Packaging the Work: Why Software Stopped Living on Servers. Module Two: Running at Scale Without Losing Sight: Resources, Releases, and the Bad Day.

Capabilities you’ll gain

  • Explain the packaging idea — why code plus its environment ships as an image, what a container isolates, and what containers buy and cost against virtual machines and plain servers
  • Read the orchestration model — what Kubernetes is and is not, and the durable objects, pod, deployment, and service, through which every deployment and outage conversation is conducted
  • Judge a running system — resources and waste, scaling, releases and rollbacks, state, configuration and secrets, and the evidence in logs, metrics, and outage reports
  • Decide like a platform lead — what Kubernetes heals and cannot heal, when containers win, when a plain server wins, and the exposing question to ask of any deployment, proposal, or incident

Finish, and you earn a certificate of completion for this course — verifiable online by anyone, anywhere.

The Course Content

What You'll Learn

A package, not a pile of files. Software that matters ships as a whole: the code, the runtime and libraries it assumes, and the defaults it starts with — frozen into one artifact whose identity can be proved, and run identically everywhere it lands.

Module 1 teaches you to package the work. The founding failure and its environment half, the image and the container, the honest ledger against servers and virtual machines, declared state, and the orchestrator's three durable objects.

Module 2 teaches you to judge the fleet. The map of a shared cluster, resource bets priced from evidence, scaling and releases judged by bottleneck and blast radius, state and secrets secured, evidence read on one clock, and healing's exact boundary.

And it builds your own standard. Five questions, answered in evidence, that decide any platform proposal workload by workload — including the ruling that leaves a workload off the platform, with the fact that would reverse it.

What you will learn

  • Explain the packaging idea — why code plus its environment ships as an image, what a container isolates, and what containers buy and cost against virtual machines and plain servers
  • Read the orchestration model — what Kubernetes is and is not, and the durable objects, pod, deployment, and service, through which every deployment and outage conversation is conducted
  • Judge a running system — resources and waste, scaling, releases and rollbacks, state, configuration and secrets, and the evidence in logs, metrics, and outage reports
  • Decide like a platform lead — what Kubernetes heals and cannot heal, when containers win, when a plain server wins, and the exposing question to ask of any deployment, proposal, or incident
What's Included

Everything in the course

  • All 18 concepts of Containers and Kubernetes: How Modern Software Runs and Ships, 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 Container Read and The Platform Decision
  • 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
Who It's For

Built for people who judge platforms

Tech-adjacent managers and leads — platform, operations, product, and delivery — who sit in deployment and architecture discussions and are expected to follow, question, and sign.

Professionals evaluating a container move — owners of a platform decision, a migration proposal, or a vendor's platform pitch — who need to judge what they are being sold.

Leaders who receive outage and rollout reports, and career movers into platform-adjacent roles — who read the incident summary the morning after and want to know which question to ask first. The course assumes no engineering background; it assumes you are responsible, or expect to be, for decisions that packaged software touches, and that you would rather understand the machine than keep nodding at it.

Prefer to learn live and in person? The same material anchors Cognosco's one-day programs — browse the in-person catalog.

Enroll

Start with The Container Read

$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.

The Lighthouse Coach — Containers and Kubernetes: How Modern Software Runs and Ships$195.00
Total · introductory price, one-time$195.00

Secure checkout by Stripe. The moment your payment completes, you are taken straight into the course to create your learner profile and begin — no account password to manage. You will receive an access key to save; it restores your enrollment on any device.

Good Questions

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, roughly 9 hours in full. 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.

Independently verified before publication — structure, claims, and sources checked; tested end to end as a learner takes it.

The Signature Series Continues

More Signature Courses are coming

Containers and Kubernetes: How Modern Software Runs and Ships is Signature Course No. 246. Leave your email and we'll send you news of future Signature Courses and Lighthouse updates as they are announced — nothing else.