One System, Five Passes: Meet Your Capstone

There's a gap that ends more interviews than any missing fact: knowing a concept and being able to use it, under pressure, on a real problem, are two different skills. You can recite what a cache does and still freeze when someone says "okay, design Uber."

This course closes that gap with one connected thread running through everything: the capstone. You'll design the same real system — a food-delivery marketplace — five times, once after each course, each pass using only the tools you've earned so far. Same system, deepening skill.

And here's the quiet part: you've already started. When you placed that order in the very first lesson and grew the marketplace from one box to a million users in the third, you were sketching Pass 1 without knowing it. The capstone isn't a new thing bolted on — it's the spine the whole course has been building along.

Scope: this lesson introduces the thread and the five passes; each pass itself lives at the end of its course, with a full brief, hints, a reference design, and a self-grading rubric. This is the trailhead — the last stop in the Welcome section before the real climbing starts.

Every other resource hands you a gallery: design Twitter, design Dropbox, design a chat app — disconnected problems you read through once. That has its place (this course has 20 such problems too). But it has a weakness: each one is a fresh start, and nothing compounds.

A single evolving system compounds. The marketplace you make transactional in Pass 2 is the same one you make survive a region outage in Pass 3, and the same one you put a cost budget on in Pass 4. Decisions carry consequences forward — exactly like real engineering, and exactly unlike a quiz.

There's a name for this shape in learning research: a spiral. Bruner's old insight, repeatedly validated since, is that revisiting the same material at increasing depth builds mastery far better than touching each idea once. Five passes over one marketplace is a spiral up a single mountain — you keep returning to the same ground with better equipment, and each return makes the last one click.

Why a food-delivery marketplace specifically? Because it's a trap in the best way: it looks simple and secretly contains almost everything hard — geography (where are the drivers?), real-time (the moving dot), payments (money must be exactly right), search (find me tacos), and brutal spikes (Friday, 7 PM). One domain, every hard problem.

Here's the whole climb, so you can see the shape before you start:

• Pass 1 — The MVP (after Fundamentals). The marketplace for launch: LB, app, cache, queue, one region — then estimate its load. The "correct one box," grown just enough.
• Pass 2 — The Data Layer (after Data Systems). Schema and access patterns, where to shard, what to replicate, and keeping inventory correct when 500 people grab the last pizza at once.
• Pass 3 — Survive Failure (after Distributed & Reliability). A region dies, traffic triples, a dependency hangs. Multi-region, overload control, SLOs, and the 3 AM incident playbook.
• Pass 4 — Productionize (after Production). Split into services where it pays, Kubernetes, CI/CD, observability — and a cost budget, the move that separates seniors from architects.
• Pass 5 — The Interview Run (after Interview Mastery). The whole system, 45 timed minutes, out loud, self-graded against the real L4/L5/L6 rubric.

Notice the difficulty rises with you. Nobody asks a Pass-1 beginner for a staff-level answer. By Pass 5, staff-level is exactly what you'll be reaching for — and you'll have five passes of earned muscle to reach with.

Each pass is built in a deliberate order, and the order is the whole point: your attempt first, then hints if you're stuck, then the reference design, then a self-grading rubric.

The temptation — especially when a pass looks hard — is to skip straight to the reference design and read it, nodding. Don't. Reading a solution feels like learning and mostly isn't; it's recognition, not retrieval. The struggle before you see the answer is where the transfer happens. Cognitive scientists call this a desirable difficulty: the productive friction that makes knowledge stick and, crucially, become usable on a different problem later — which is the entire game an interview is testing.

So the rule is simple and occasionally uncomfortable: design it yourself, badly if necessary, before you look. A wrong first draft you then compare against the reference teaches more than a perfect solution you merely read. Your Pass 1 will be rough. Good. Roughness you correct is exactly how Pass 5 gets sharp.

Here's the full roadmap, clickable. Each pass shows what you'll design, the constraints waiting for you, the tools you'll have earned by then, and what your self-grade focuses on.

Try this first: click Pass 1 and Pass 5 back to back. Read them as the same system seen by two different engineers — the one you are now, and the one you'll be. The distance between those two descriptions is what this course is for.

The capstone costs something real: time and discomfort. Designing a system yourself, before you feel ready, then having a reference design show you everything you missed — that's more effortful than reading a worked solution, and it stings a little. Skipping the passes is always the tempting option, and always the wrong one.

What it buys is the only thing that actually matters in an interview room or a design review: transfer — the ability to take concepts and apply them to a problem you haven't seen before. That's precisely the skill a gallery of pre-solved problems can't give you, because reading someone else's answer never builds your own retrieval.

The honest failure mode isn't doing the capstone wrong — it's not doing it. A learner who reads every lesson and skips all five passes will know a great deal and be able to do surprisingly little. Don't be that learner. Rough attempt, then reference, then honest self-grade — five times. That's the deal, and it's the best one in the course.

A two-minute head start on Pass 1 — do it now, before you've "officially" learned anything more:

1. On paper or a whiteboard, sketch the food-delivery marketplace as best you can right now. Boxes and arrows. Client to... what? Don't look anything up.
2. Circle the parts you're unsure about — the boxes you drew on faith.
3. Keep the sketch. When you reach the real Pass 1 after Course 1, draw it again and lay them side by side.

Check: if your sketch right now is just "phone → server → database," that's a perfect starting point — it means every lesson ahead adds a box you'll understand the reason for. And if you drew twelve boxes confidently? Pass 1 will test whether you can defend each one. Either way, the sketch you keep is the before-photo of your own progress.

• "Capstones are beginner/bootcamp stuff." → Transfer — applying concepts to a novel system — is exactly what senior interviews test. The Pass 5 rubric is L4/L5/L6. This is the deep end, not the shallow.
• "I'll do all the passes at the end." → They're spaced one per course on purpose. The spiral only works if each pass sits on freshly-learned tools; batching them at the end collapses it back into cramming.
• "Reading the reference design = doing the pass." → Recognition isn't retrieval. The struggle before the reference is where the learning is; skip it and you've watched, not learned.
• "My Pass 1 should be good." → It should be rough. A wrong draft you correct against the reference teaches more than a clean answer you copied. Roughness is the feature.
• "Five designs of one app is repetitive." → It's a spiral, not a loop — same ground, deeper each time. Pass 3 asks questions Pass 1 couldn't even parse.

• The capstone is one system — a food-delivery marketplace — re-designed five times, once after each course, each pass using only the tools you've earned. Same system, spiraling depth.
• It exists to close the gap between knowing and doing — transfer, the skill interviews actually test and galleries of pre-solved problems can't build.
• One evolving system beats fifty disconnected ones: decisions compound, and revisiting the same ground at increasing depth (a spiral) builds real mastery.
• The rule is attempt before you peek: your draft → hints → reference → self-grade. The struggle before the answer is where learning happens (a desirable difficulty).
• You've already started — the order you placed and the marketplace you grew were Pass 1 forming. Your Pass 5 answer will be unrecognizable beside your Pass 1. That gap is the point.
• Next — you've finished the Welcome section. The checkpoint is up: a few scenarios to confirm the mindset before we open the hood on real hardware in Computer & OS Foundations.