system-design

The Reading List

This repo is a complete course, but system design is a lifelong subject. This is the curated reading list to go deeper — the books and courses worth your time, roughly ordered from beginner to advanced, with a note on when to read each. You don’t need all of them; pick based on where you are.

Time to read: ~10 minutes; a lifetime to work through

How to use this list

🚨 Don’t try to read everything — that’s a procrastination trap. This repo + deliberate practice is enough to pass interviews. Use this list to (a) go deeper on topics you love, (b) fill a specific gap, or (c) keep growing after you land the job. Pick one book at a time, and apply it (build something, redo a case study) rather than just reading.

Books — the essentials

Start here (beginner-friendly)

Grokking the System Design Interview / System Design Interview (Alex Xu, Vol 1 & 2). The most popular interview-focused resources — worked case studies in a consistent format (much like Part 12). Great for interview prep specifically. Read alongside this repo’s case studies.
ByteByteGo (Alex Xu’s site/newsletter). Digestible explainers and diagrams; good for casual, steady learning.

The one book to truly understand data systems (essential)

🚨 Designing Data-Intensive Applications (Martin Kleppmann) — “the DDIA book”. The single most recommended book in this field. Deep, rigorous, and readable coverage of storage engines, replication, partitioning, transactions, consistency, consensus, batch/stream processing. If you read one book, read this. It’s the backbone of Parts 3 and 4. Not interview-specific but makes you genuinely understand everything.

Going deeper (intermediate → advanced)

Understanding Distributed Systems (Roberto Vitillo). A clear, modern, approachable tour of distributed systems — a gentler complement to DDIA.
Database Internals (Alex Petrov). How storage engines and distributed databases work under the hood (B-trees, LSM-trees, consensus). For when you want the deep DB layer.
System Design Interview and Acing the System Design Interview (various). Additional interview- focused compilations if you want more worked examples.
Building Microservices (Sam Newman). The definitive practical guide to microservices and service decomposition — pairs with Part 5.
Release It! (Michael Nygard). Resilience, stability patterns, and production failure modes — wonderful, war-story-driven — pairs with resilience patterns.
Site Reliability Engineering (Google, free online). How Google runs production — SLOs, incident management, operations — pairs with Part 8.

Adjacent but valuable

The Pragmatic Programmer and Clean Code — general engineering craft; help the LLD/coding rounds.
Domain-Driven Design (Eric Evans) / Implementing DDD (Vaughn Vernon) — modeling and service boundaries.

Courses & structured learning

Educative — Grokking the System Design Interview (and the Grokking series). Interactive, interview- focused; a common companion to this repo.
MIT 6.824 Distributed Systems (free online) — 🚨 a rigorous, famous course with lectures, papers, and labs (build Raft, a KV store). Advanced but transformative if you want true depth.
University courses on databases, distributed systems, and OS (many free: CMU Database Systems, Berkeley, etc.) — for the fundamentals underneath.
YouTube: ByteByteGo, Gaurav Sen, Hussein Nasser, System Design Interview channels — good for casual reinforcement (but active practice beats passive watching).

A suggested reading order

flowchart LR
    A[This repo +<br/>case studies] --> B[Alex Xu vol 1-2<br/>interview reps]
    B --> C[DDIA<br/>true understanding]
    C --> D[Pick specialties:<br/>microservices / SRE /<br/>DB internals / 6.824]

Now (interview prep): this repo + practice + Alex Xu’s worked examples. Enough to pass interviews.
Next (real understanding): DDIA, cover to cover, applying it to the case studies.
Then (depth by interest): pick specialties — microservices, SRE, database internals, or the 6.824 course.
Ongoing: engineering blogs and papers.

🚨 Reading order matters less than applying what you read. After any chapter, redo a case study or build something with the new lens.

🛠️ Try it

1. Buy/borrow DDIA and start it. Read one chapter, then map it onto a case study in this repo (e.g. the replication chapter → the KV store). Applying it makes it stick.

2. Pick one course to commit to. If you want depth, enroll in (or bookmark) MIT 6.824 or a database course and schedule it. One deep course beats ten half-watched videos.

3. Don’t hoard. Choose one book to actually finish next, and ignore the rest until you do. The list is a menu, not a to-do list.