The Lighthouse · Signature Series

MongoDB in Practice

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

No experience needed — your coach starts where you are.

Preview This Course — Free
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 MongoDB in Practice 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.

The document is the unit of design. In MongoDB, the document is the unit of design, of storage, and of atomic work — so the first design question is never “what are my tables?” but “what is the thing my application loads, shows, and saves as one piece?” That bundle is the aggregate, and this course builds the practitioner who can find aggregates honestly: model from screens, jobs, and questions — never from entity lists — size every boundary with printed arithmetic, and defend every choice by the access pattern it serves.

It runs on one stipulated case. Cedarvale Pantry is a regional grocery and meal-kit business — 14 stores, a small warehouse, and an online ordering service — rebuilding its ordering system on MongoDB: a catalogue of 25,000 products, 500,000 registered customers, 10,000 orders on a typical day at an average of 8 item lines, and an operational event log receiving 50,000 events a day. Its team's instincts are relational — which is precisely why they are useful to learn with: every mistake this course warns against is one this team is tempted to make first.

It starts with the model. Documents first — then the embed-or-reference decision with its costs counted on both sides, schema given a deliberate shape, queries and pipelines that respect the model, indexes placed as a portfolio of bets on named queries, arrays ruled by the bounded-owned-calm tests, and consistency governed flow by flow, with transactions kept for the narrow residue that genuinely needs them.

It works in two movements. First, Module 1 — Model and Read: The Document Discipline — work through Concepts 1–9, finishing with The Cedarvale Model — A Data Model and Query Dossier; then, Module 2 — Run It in Production: Copies, Scale and Stewardship — work through Concepts 10–18, finishing with The Production Review — Auditing Cedarvale at Scale.

Both capstones produce real artifacts — a defended data model and query dossier for the running case: the operations inventoried, every boundary drawn by access pattern and priced, the schema record, duplication register, and uniqueness set written down, and the dominant queries specified with the indexes that serve them; and a complete production review of that system at scale — capacity recomputed in the room, plans and usage read as evidence, recovery and security claims tested against rehearsals and maps, and the whole issued as a graded findings register a working team could act on.

The honesty standard is part of the course. This is a practice course, not an exam course: there is no certification framing anywhere in it and no promise about any third-party credential. Every number in the course recomputes — worked figures are printed with their arithmetic, in decimal units stated wherever the distinction matters — and the perishable specifics that change as the product is revised, from service tiers to version-specific limits, are fenced to the book's Appendix, to be confirmed at the source before anyone relies on them.

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.

MongoDB in Practice 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.

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 the boundary. Pick the central record of a system you know and say which operations load it whole and which load only a slice of it — and what that split tells you about where its document boundary should sit; say where one logical thing gets reassembled from many stored pieces on every read, and who pays that cost, how often; and name which part of your central record grows with history rather than with the thing itself, and where that growth currently lives. 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 Cedarvale Model — A Data Model and Query Dossier for Module 1 and The Production Review — Auditing Cedarvale at Scale for Module 2 — that pull the whole course together, and earn the certificate.

The Course Content

What You'll Learn

The access pattern is the design. Every modelling, indexing, and scaling decision in this course is derived from what the application actually reads and writes. A decision that cannot name the access pattern it serves is a guess wearing a design's clothes — and every convenience is a cost moved, not a cost removed, so the practitioner's skill is choosing which cost, paid where, on purpose.

Module 1 builds the document discipline. The aggregate found from the operations list; embedding against referencing with round trips and growth counted; schema on purpose — common core, validation, versioning, and change that never breaks a running reader; queries and pipelines in the model's grain; indexes designed from real queries under the ESR guideline; arrays placed by the bounded, owned, and calm tests; and the governance — uniqueness, duplication, and drift — that keeps a flexible store honest.

Module 2 runs it in production. Query plans read by their three numbers until healthy ratios are an instinct; index coverage, selectivity, and housekeeping; replica sets with write concern and read preference set by named harms; shard keys scored on cardinality, distribution, and alignment; the working set estimated from what the hot operations actually touch; restores rehearsed, timed, and verified; least-privilege security under encryption and audit; data retired on a written lifecycle; and the whole system audited end to end in the design review that closes the course.

And it holds its boundary throughout. This course works at workflow and judgment level — how to decide, how to check, and how to review — not which button to press in a console: no click-paths, and no examination or certification preparation of any kind. Where a command or an operator name is itself the judgment, the course names it; where the detail is a menu path, it teaches the question to ask of the documentation in front of you.

What you will learn

  • Model a workload as documents: identify aggregates from real access patterns and draw document boundaries you can defend in a design review
  • Decide, case by case, between embedding and referencing — and state the cost of each choice in reads, writes, and growth, with the round trips counted
  • Give a flexible schema a deliberate shape: validation at the store for genuine invariants, a version marker on every document, and change by expand, migrate, contract
  • Write queries and aggregation pipelines that respect the model — and predict what they will cost, stage by stage, before you run them
  • Design indexes from the queries you actually run, prove service from a query plan's examined-to-returned ratios, and keep the index set lean
  • Govern consistency honestly: uniqueness enforced by the store, duplication governed by a written register, drift patrolled, and transactions kept narrow
  • Run the system: replica sets and read preferences set by named harms, a shard key scored on cardinality, distribution, and alignment, and a working set you can compute
  • Protect the system: backups you have restored from, least-privilege access, encryption in transit and at rest, and audit that answers whose credential did what
  • Manage the data's whole life — retention, expiry, and archiving ruled in advance — and audit a complete MongoDB system end to end from evidence
What's Included

Everything in the course

  • All 18 concepts of MongoDB in Practice, 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 Cedarvale Model — A Data Model and Query Dossier and The Production Review — Auditing Cedarvale at Scale
  • 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 the people who model and run the store

Developers, data engineers, and technical leads who build on MongoDB now — or who are about to adopt it and want the design decisions made deliberately rather than discovered in production. It assumes you can already write basic queries in some database and read a JSON-like document without help; it assumes no prior MongoDB depth.

The experienced relational modeller — much of this course is the disciplined unlearning of reflexes that were virtues elsewhere and are liabilities here: the aggregate reassembled by joins on every read, normalization as an unexamined default, and the transaction reached for as a first answer.

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

Enroll

Start with Documents First

$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 — MongoDB in Practice$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. 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

MongoDB in Practice is Signature Course No. 569. Leave your email and we'll send you news of future Signature Courses and Lighthouse updates as they are announced — nothing else.