Course Introduction

Welcome: How This Course Works

System design has a reputation for being endless: a hundred technologies, a thousand blog posts, architectures that look nothing like each other. Here's the secret this course is built on: underneath all of it are about sixty recurring patterns, and engineers who know the patterns can design systems, and pass interviews, that engineers who memorized architectures cannot.

A pattern isn't a technology. Redis is a technology; cache-aside is a pattern: a problem shape, a standard solution, and a price tag, and it would still be true if Redis vanished tomorrow. Patterns are the vocabulary of system design: learn the vocabulary, and every "design X" problem becomes a composition exercise instead of a memory test. That claim gets its full defense in the first lesson.

Who This Is For

Software engineers from mid to senior levels, and the data engineers and AI engineers who keep discovering that their pipelines and inference stacks are distributed systems wearing costumes. You need no distributed-systems background: if you know what a server, a database, and an HTTP request are, you're equipped. Every term beyond that gets defined when it first appears, and every pattern is anchored to something you already know from everyday life: a phone call, a to-do list, a bank statement, a fuse box.

The Map: Twelve Modules

The course tells one continuous story: an online store, growing from one database box to a hundred million users, hitting every wall in the standard order.

How to Read

The default path is in order: modules build on each other deliberately, and later lessons spend earlier ones without re-teaching them.

How each lesson works: pattern lessons open with an incident: a system on fire, with real numbers: because patterns only make sense as answers to problems you've felt. Then the naive fixes (and why they fail), the pattern itself, a numbers walkthrough, honest trade-offs, when not to use it, a face-off against its nearest rival, real-world sightings, an interview lens with a memorizable 30-second answer, a self-check quiz, and a TL;DR card. The cards collect into a course-wide reference deck: before an interview, re-reading just the cards is a legitimate strategy. Lessons come in two sizes (full and compact): simple patterns get short lessons on purpose, because padding is how courses die. And each module ends with a mini-capstone that composes everything the module taught.

One rule we enforce everywhere: every pattern includes when not to use it. Half of senior judgment is restraint, and interviewers score it.

This Module

Three short lessons, no patterns yet:

1. Thinking in Patterns: what a pattern is, why sixty is enough, and why composition beats memorization.
2. The Five Questions: the mental model that turns a blank whiteboard into a plan: how data flows, where it lives, how it's served fast, what happens on failure, and how it grows.
3. The Arithmetic: the four calculations this course reuses constantly: rate × duration, availability multiplication, the latency ladder, and hit-ratio math. Twenty minutes here pays for itself forty times over.

Then the store opens for business, and Module 2 starts drawing arrows.