How to use this course + the workbook

Five minutes now saves you from wandering later. Here's the shape of the whole thing, what each asset is for, and the one habit that decides whether any of it sticks.

Start Here, then the modules build from the ground up

You are in Chapter 0. After it, the modules run in one direction, from the raw trade-offs up to a full system you can design, defend, and operate:

• The 6 Core Trade-offs the axes every later decision is a move on
• Capacity Estimation the one number that bounds the design
• Choosing a Data Store, then Data at Scale how data is modelled, then how it survives growth
• APIs and Networking, then Distributed Systems how the pieces talk, and how they fail, across a network
• Architecture and Domain Design drawing service boundaries that hold
• Reliability and Operability keeping it up, and knowing when it isn't
• Capstone: Worked System Designs the whole method, run end to end on real systems

Each lesson is one idea. That's deliberate: short enough to finish in a coffee break, focused enough to remember.

Each asset does a different job. Use them differently

• Lessons The teaching. Read or watch at your pace, one idea each, with a diagram and a typed code example where they make the idea concrete.
• Cheat sheets One-page references, sitting at the end of the module they summarise. For fast recall before an interview or a review.
• Worked designs Full systems reasoned end to end, from requirements to trade-offs. The capstone payoff, the method at full length.
• Case studies A technique walked one step at a time on a real example (event storming a live codebase). The method applied, not just described.
• Projects and ADRs The workbook. What you produce yourself, placed at the end of the module where the work is done. This is where it sticks.

Lessons teach, cheat sheets remind, worked designs and case studies show the method whole, and the projects are where you actually change.

A lesson isn't done when you've read it

It's done when you can say the trade-off out loud and name the one thing that would change your mind. Reading builds recognition; saying it back builds the muscle the interview and the design review actually test.

In order for the first pass. The axes compound

• First pass: in order Go start to finish. Each axis builds on the ones before it; skip ahead and later lessons assume ideas you haven't met yet.
• After that: reference Once the base is in, jump anywhere. Pull a single lesson before a review, a cheat sheet before an interview. It's yours to raid.

"The axes compound" is literal: latency ↔ throughput only makes full sense after consistency ↔ availability. Order is a feature, not a formality.

After each module, do the project. Don't just read

Passive review builds recognition, "oh right, I've seen that." The interview and the design review need production: reasoning it out from a blank page. Only the projects train that, because only they make you generate instead of recognise.

If you do one thing differently because of this lesson, make it this: finish the module, then produce the artifact before moving on. That single habit is most of the result.

A study loop that actually compounds

The loop repeats once per module: read, explain, produce, file the cheat sheet, then start the next module the same way. Skipping straight from "read" to "next module" is the failure mode this lesson is warning you about.

• Read the module's lessons in order. Note the ones you would struggle to explain, and study the diagrams. One sitting per idea.
• Explain one idea out loud. Pick the hardest lesson and say the trade-off to a rubber duck: the position you chose, its cost, and the trigger that would change it. If you can't, reread that one.
• Do the project from blank. Produce the design or ADR yourself. Struggle is the point; it's the muscle the module was building.
• Keep the cheat sheet handy. File it for the day you need fast recall. On later passes, the sheet alone re-loads the whole module.

Know the shape, say it back, and do the projects. Then it sticks

1. The shape: Chapter 0, then modules that build from the trade-off axes up to a full system, ending in a capstone. One idea per lesson.
2. The assets: lessons teach, cheat sheets remind, worked designs and case studies show the method whole, and the projects are where it sticks.
3. The path: in order for the first pass because the axes compound, then use the whole thing as reference. Say each idea out loud to make it yours.
4. Next: 0.3 · The Staff mindset: "it depends" is the answer, the frame every axis after it hangs on.