Home / System Design / Start Here

Start Here

These notes assume system design is not new to you. The goal is fast, targeted review — not learning from scratch. Each section has a clear job. Use this page to orient yourself and jump to what you need.

How This Guide Is Structured

Nine sections. Read them in order the first time. After that, use them as targeted reference.

Section 1
Fundamentals
Core vocabulary — Regions, AZs, Primary/Replica, Sharding, Stateless vs Stateful, CAP Theorem, Consistent Hashing, Hot Keys.
Reach for it when: you want to confirm you're using terms correctly, or you're fuzzy on a foundational concept.
Section 2
Non-Functional Requirements
Scale, Latency, Availability, Consistency, Durability, Fault Tolerance, Security, Compliance, Monitoring. Includes NFR-to-architecture mapping and a quick reference table.
Reach for it when: you're starting a design and need to clarify what the system actually needs before drawing anything.
Section 3
Layers
The Core 4 layers every system needs, optional layers and when to add them, a latency reference table, and 5 scenario diagrams with full latency breakdowns.
Reach for it when: you need to draw a system diagram. Start here after NFRs — the scenarios show exactly which layers each NFR demands.
Section 4
Building Blocks
Deep reference on every component — Redis (cache, pub/sub, geo, locks), Kafka, CDN, SSE/WebSockets, geospatial, distributed coordination, CDC, payments, video streaming, and more.
Reach for it when: you know what type of component you need and want the full picture — limits, tradeoffs, real examples, when not to use it.
Section 5
Tech Selection
Decision trees for every category — SQL vs NoSQL, Kafka vs SQS vs RabbitMQ, Redis vs Memcached, ALB vs NLB, API Gateway, Object Storage, Search.
Reach for it when: you know you need a message queue (or cache, or database) but need to justify which specific technology and why.
Section 6
Capacity Estimation
Numbers to memorize, core formulas, and three fully worked examples — Twitter, YouTube, WhatsApp — showing QPS, storage, and bandwidth from first principles.
Reach for it when: you're brushing up on estimation before an interview. Work through the examples yourself without looking at the answers.
Section 7
What-If Scenarios
20 failure scenarios — Redis crashes, DB failover, traffic spike, hot keys, cache stampede, Kafka lag, CDC down, and more. Each includes cascade, peak-traffic variant, prevention, and recovery.
Reach for it when: an interviewer asks "what happens if X fails?" or "how would you handle 10× traffic?" Pick 5–6 scenarios relevant to your target role and read cold.
Section 8
Case Studies
End-to-end designs showing how building blocks compose into real systems. Each study identifies the NFRs, picks the right components, and walks through the tradeoffs.
Reach for it when: you want to see the pieces fit together for a specific problem. Read it, then try to reproduce the design from memory.
Section 9
Kafka Study Guide
Deep dive on Kafka internals — Topics & Partitions, Producer Partitioning, Consumer Groups & Assignment, Replication & Durability, Offset Management, Compacted Topics & CDC, Exactly-Once Semantics, and system design patterns with hot key solutions across 7 real systems.
Reach for it when: Kafka comes up in an interview or design — covers every layer from producer config to partition math, with Java code for every pattern.

First pass — build the vocabulary (Sections 1–3): Read Fundamentals, NFRs, and Layers in order. By the end you should be able to draw a layered diagram for any scenario in Section 3 from memory.

Second pass — build the toolkit (Sections 4–6): Read Tech Selection and Capacity Estimation fully. Use Building Blocks as a reference — look up components as they come up, not end-to-end.

Third pass — stress-test (Sections 7–8): Pick 6 What-If scenarios relevant to your target systems and read them cold. Then read the Case Studies and try to reproduce each design before checking.

Deep dives (Section 9): Use the Kafka Study Guide when Kafka is a focus area — before a Kafka-heavy interview or when you want to go beyond the Building Blocks overview into internals, config choices, and partition math.

Day-before: Skim the Section 3 scenario diagrams and the Section 5 quick reference table. That's it.

PreviousConcurrency