Changelog

Module 9 now judges a service boundary from ownership, operating need, data, and coupling instead of an abstract score. Its four scenarios teach distinct decisions—including when a modular monolith is the safer design—and connect every boundary to what a user actually experiences.

Every consistency, replication, and consensus lesson now replays its real causal mechanism—from session versions and WAL positions to Raft votes and fencing generations. Simple mode uses concrete computer actions, while Advanced mode makes assumptions explicit and tests the misconceptions that make these failures easy to misdiagnose.

Module 5 is now complete. Explore consistency models, session guarantees, acknowledgement boundaries, replica topologies, failover, split-brain, regional designs, conflict resolution, Raft, and fencing tokens through stepped Simple and Advanced scenarios.

The new CAP / PACELC lesson lets you cut the link between two copies, see a stale answer or an explicit refusal, and compare the time a careful read takes when the link is healthy. Try it in a cookie shop, ticket sale, wallet, or ride dispatch scenario.

Every implemented lesson now follows the same simplicity, clarity, coherence, and relevance rubric. Simple predictions and activities lead with believable scenario outcomes, while Advanced mode retains implementation details, operational assumptions, and trade-offs.

Every Module 2 lesson and scenario now follows the same teaching-quality rubric. Activities more clearly separate experiments with timing or deployment shape from the production mechanisms that actually keep a system safe.

Simple concurrency scenarios now keep outcomes in the timeline and explanation instead of repeating them in separate inventory or count cards.

Guess and Predict choices now appear in a stable question-specific order, so the correct answer’s position cannot become an unintended hint.

Simple activities now label their two actions directly: first arrange the draggable setup, then play it. The playback button no longer competes with the challenge as a separate “Watch it happen” path.

Replay controls now stay in one stable place from start to finish. Prediction explanations and their completed outcomes also appear together in a single card.

Finished replays now place Back and the next lesson-stage action together below the outcome. Redundant cookie-count cards have also been removed across the Module 2 cookie scenarios.

The Read-then-write race activity now keeps its outcome focused on what happened instead of repeating the same cookie counts in a second set of cards.

Distributed now uses one consistent set of names: modules contain lessons, and each lesson can be explored through several scenarios.

The Read-then-write race lesson now shows that each request works from a value saved on its own screen, separates making one run safe from fixing the system, states its database execution assumptions, and keeps the Advanced lab focused on the failure with one preview of the next lesson's atomic fix.

Lesson controls, mode switches, and story selectors now show a pointer cursor on hover so clickable pieces feel more immediately interactive.

Seam Finder turns monolith-versus-microservices into a hands-on boundary decision. Compare a cookie shop, ticket release, digital wallet, and ride dispatch while mapping team ownership, scaling pressure, and data coupling in Simple or Advanced mode.

Every "Watch" and "Guess"/"Predict" screen in Module 3 (queues, retries, sagas, outboxes, and the rest of reliable asynchronous processing) now opens with a short title and a reading note pointing at what to look for, matching the treatment Module 2 already had. This closes out the shared visual design language work across the app.

Module 7 is now playable. Four new field notes follow a hotel booking from search to payment:

• Nightly inventory: pick a stay on a room × night grid and see which queries offer a room that's sold out on one night.
• Availability bitmaps & segment trees: combine yes/no lists per night, then compare the work against a budget as stays get longer and updates pour in.
• Search as a derived view: book while the search copy is still out of date, and see why booking rechecks the real inventory and price.
• Holds & expiry: save rooms while a guest pays, then let the card fail, the guest leave, or the bank take too long.

Each concept has a small-inn story plus three realistic examples in both Simple and Advanced modes.

Module 11 is now playable from review through delivery. Four new field notes teach learners to trace critical writes and reads, classify findings, plan thin capability slices, and structure full system-design exercises across four realistic examples apiece.

In At-least-once delivery & idempotent consumers, the "killed" caption on a crashed worker could print right over the next worker's name on a narrow screen. The label now sits with more room below the caption.

Timeline rows that hold marbles, like the Kafka partitions in Queues vs pub/sub, now leave room for their captions. On a narrow screen a caption no longer prints over the label of the lane below it.

In Progress tracking & cancellation, the cancel request now gets its own track under the progress bar. When the worker keeps going after you press cancel, its step labels and "cancel_requested" no longer print on top of each other.

Several Predict and Guess stages showed the answer before you picked one. Now they don't:

• Transactional outbox: the consumer's delivery looks normal until you answer, and the "ghost event" appears as its own step afterwards. In the payment example, the relay no longer publishes before the crash.
• Dead-letter queues: a message's last failure and its move to the DLQ are now two separate steps, so the pause falls between them. The "skip" guess now pauses before update ④ is tried.
• In any walkthrough whose pause lands on the final step, the diagram keeps hiding what comes next until you answer.

In the At-least-once delivery lab, "Check, then record" now records the message id as its own step, a moment after the side effect. Drop the crash between the two and the redelivered message's check finds nothing, so the side effect runs twice. Before, the takeaways could only describe this.

In At-least-once delivery, the timeline only shows the crash lane when there is a crash. Turning the crash on or off in the lab now slides the worker lanes smoothly instead of leaving an empty row.

Module 10 is now playable from end to end. Six new field notes let you budget reliability, connect telemetry, respond to pages, inject controlled failures, stop unsafe canaries, and verify distributed deletion across four realistic examples apiece.

The "Stock over Kafka" lab in At-least-once delivery now uses Kafka's own words: the message ends in "offset committed" instead of "deleted", and the options read "Commit after processing" and "Commit before processing".

Module 8 is now playable from end to end. Nine new field notes let you trace tenant boundaries, break and repair shared queues, compare rate limiters and scaling signals, contain retry storms, and schedule scarce GPU capacity across four realistic examples apiece.

Module 6 is now playable from relational, key-value, and document modeling through indexes, sharding, specialized stores, object storage, and full-text search. Each lesson compares the same workload across designs so you can see where the work moves and why a fit changes.

Cache-capacity labs now ask you to predict an exact outcome before the simulation unlocks. Commit to a number, then compare it with the real result and a practical rule of thumb.

Advanced mode in the isolation-level, deadlock, and at-least-once lessons now names the rule each run protects, in the example's own terms ("one hold per fan", "payment pi_3N credits the wallet exactly once"). It reads "watching" while the replay plays, then shows whether the rule held, and the lab's outcome card shows the same readout.

The changelog now explicitly sorts in reverse chronological order, including predictable newest-first ordering when several updates ship on the same day.

Changelog cards now focus entirely on what changed and when, without displaying internal agent names or commit hashes.

This changelog is now the home for brief, reader-facing notes about every change our agents ship. Entries live in markdown, so they can grow from a sentence into bullets or a screenshot when a release deserves it.

Module 4 is now playable from start to finish, with new lessons on cache strategies, stale data, stampedes, hot keys, negative caching, and cache outages.

• Each lesson includes Simple and Advanced walkthroughs.
• Three realistic examples accompany every concept.
• New simulations cover both failure cases and the protections that fix them.

The database concurrency lessons now have a fully checked set of realistic stories and hands-on challenges. Mobile layouts, light and dark themes, and every Simple and Advanced interaction received a visual pass.

Module 1 now teaches six system-design foundations through interactive explorers, from load balancing and service discovery to consistent hashing and back-of-envelope estimation.