Skip to content
Zainan Victor Zhou, zThink author and Ethereum EIP Editor zThink by Victor Zhou

Navigation
← All articles
ZTHINK engineering

How to Prepare for Software Engineer System Design Interviews: The Resources

A list of classic textbooks for system design interviews: DDIA for the foundations, then architecture trade-offs, domain modeling, reliability, classic patterns, and the original papers from MIT's distributed systems course. Each book is checked against its publisher's page.

Aileen Wright
By
Edited by Zainan Victor Zhou
阅读中文版 ↗
How to Prepare for Software Engineer System Design Interviews: The Resources — Aileen Wright
On this page

A system design interview tests how you design a large software system: how you store data, how you route requests, what happens when a machine fails, and what each choice costs. That knowledge comes from the classic textbooks of the field. This article lists only textbooks and classic works. It does not include books that teach interview questions. The list has six groups and ends with the reading order that I recommend.

On 30 October 2026, I checked the author, edition, and publication date of each book against the publisher’s page or the author’s own page. Several books on the list now have a new edition, so check the edition before you buy.

The first group explains data systems and distributed systems

A house foundation under construction, with a thick blue book set into the stone footing as the cornerstone

Designing Data-Intensive Applications is the foundation of the list

Martin Kleppmann’s Designing Data-Intensive Applications is usually called DDIA. The table of contents of the second edition starts with data models, storage, and encoding. Then it moves to replication, sharding, transactions, and the trouble with distributed systems. Most of the trade-offs that interviewers ask about have their background in those chapters.

Two editions of DDIA exist. Kleppmann wrote the second edition with Chris Riccomini. The O’Reilly page gives the publication date as February 2026, and the book list on Kleppmann’s homepage says March 2026. Kleppmann wrote the first edition alone, and O’Reilly published it in March 2017. If you have a choice, read the second edition.

Understanding Distributed Systems gives a fast overview

Roberto Vitillo’s Understanding Distributed Systems is shorter than DDIA. The book’s website says that the current version is the 2nd edition, with 33 chapters and 328 pages. The book has five parts: communication, coordination, scalability, resiliency, and maintainability. You can read the first two chapters for free on the website.

The author says that the book focuses on breadth more than depth. It covers the network stack, data consistency models, scalability and reliability patterns, and observability. If you have little backend experience at scale, read this book first and DDIA second.

Database Internals goes deeper into storage engines

Alex Petrov’s Database Internals was published by O’Reilly in October 2019. The book’s website says that the book has two parts, Storage Engines and Distributed Systems. The first part covers B-trees, LSM trees, and the write-ahead log. The second part covers failure detection, leader election, consistency models, and consensus.

Interviews seldom go this deep. But an interviewer can ask why a database writes fast, or why your storage choice fits the read/write ratio. A reader of this book can answer at the level of the data structures.

The second group gives a framework for architecture trade-offs

A brass balance scale on a drafting table, with a model of one large building on one pan and a cluster of small connected houses on the other, almost level

Fundamentals of Software Architecture compares architecture styles

Mark Richards and Neal Ford published the second edition of Fundamentals of Software Architecture with O’Reilly in March 2025. This edition has five new chapters. The first chapters define architecture characteristics, which are requirements such as scalability and availability that are not features. Then the book discusses microservices, modular monoliths, microkernels, layered architectures, and other styles one by one. A frequent follow-up question in an interview is “why this design and not that one?” This book gives you the words and the steps to compare designs.

Software Architecture: The Hard Parts is about problems with no best practice

Software Architecture: The Hard Parts has four authors: Neal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghani. O’Reilly published it in October 2021. The title of chapter 1 is “What Happens When There Are No ‘Best Practices’?”. The book discusses service granularity, contracts between services, and distributed transactions. Interviewers often ask about these topics too.

Two books about code-level design are optional

The next two books are about design at the level of modules and code. They have little to do with distributed systems, so they are optional for interview preparation.

Robert C. Martin’s Clean Architecture was published by Pearson in September 2017. Its table of contents has three main parts: design principles, component principles, and architecture. One chapter is about how to draw boundaries.

John Ousterhout is a professor of computer science at Stanford. He released the second edition of A Philosophy of Software Design in July 2021. The second edition adds sections to two chapters that compare the book with Robert Martin’s Clean Code. Ousterhout writes that the two authors have significant differences of opinion about the length of methods and the role of comments. If you read both books side by side, you see the design trade-offs more clearly than if you read only one.

The third group covers domain modeling and service boundaries

A hand-drawn town map divided into districts by coloured-pencil boundary lines, with a small wooden house in each district

When an interview question asks how to split a system into services, you need the concepts of domain modeling.

Eric Evans’s Domain-Driven Design was published by Addison-Wesley in August 2003. Domain Language, the training company where Evans teaches, calls it “The Big Blue Book”. Ubiquitous Language, Aggregates, and Bounded Context are concepts that you hear often in interviews, and each one has its own section in the book.

Vaughn Vernon’s Implementing Domain-Driven Design was published by Addison-Wesley in February 2013. It shows how to apply Evans’s concepts in a real project.

Sam Newman’s Building Microservices, second edition, was published by O’Reilly in August 2021. Newman says that the second edition is a complete rewrite of the first. The first chapter is free on his website.

The fourth group covers reliability and operations

A cutaway sailing ship whose hull is divided by bulkheads, so that water in the flooded compartments stays contained and the ship floats level, with a lighthouse in the distance

Google gives away three SRE books

O’Reilly published the first edition of Google’s Site Reliability Engineering in April 2016. Google puts the full text online for free at sre.google. The companion book The Site Reliability Workbook and Building Secure & Reliable Systems are also free to read online. Service level objectives (SLOs), load balancing at the frontend and in the datacenter, and handling overload all have their own chapters.

Google has also released a completely rewritten second edition. On the sre.google books page, the second edition has only a link to buy it from Google Books, with no link to read online. The free book is still the first edition.

Release It! explains how systems fail in production

Michael Nygard’s Release It!, second edition, was published by the Pragmatic Bookshelf in January 2018. The book has a chapter on stability patterns, which include timeouts, circuit breakers, and bulkheads. When an interviewer asks what happens if a downstream service fails, you can answer with these patterns.

The fifth group is classic pattern catalogs for reference

A library card catalog with one drawer open and a few index cards on the desk, each showing a small diagram of boxes and arrows

These three books are more than twenty years old, and their technology examples are dated. I use them as reference books: when I see a pattern name that I do not know, I look up that one chapter.

Martin Fowler’s Patterns of Enterprise Application Architecture came out in 2002. Fowler says that the first part is a tutorial of about 100 pages, and the rest is a reference to forty or so patterns. The topics include how to layer an enterprise application, how to organize domain logic, and how to connect that logic to a relational database.

Gregor Hohpe and Bobby Woolf’s Enterprise Integration Patterns was published by Addison-Wesley in October 2003. It contains 65 integration patterns for systems that communicate with messages. The pattern list on the website includes the Publish-Subscribe Channel, the Dead Letter Channel, and the Idempotent Receiver. You use these concepts when you design a message queue in an interview.

Design Patterns, by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, was published by Addison-Wesley in October 1994. It is about patterns in object-oriented code, so it helps less with system design interviews.

The sixth group is an open course and its original papers

An open sketchbook with the same bridge drawn many times, next to an hourglass

MIT’s distributed systems course 6.5840 (formerly 6.824) puts its schedule, readings, and labs online. The Spring 2026 schedule asks students to read papers before class, for example GFS (2003), Raft (2014), and Spanner (2012). The labs ask students to build MapReduce and Raft. If you want to find the original paper behind an idea in DDIA, use this schedule as a reading list.

I recommend this reading order

  1. Read DDIA first for the foundations. If you have little experience, read Understanding Distributed Systems before DDIA.
  2. Read Fundamentals of Software Architecture next. It gives you a method to compare designs, so you can explain why you chose one.
  3. Choose the books on domain-driven design, microservices, and SRE that fit your target role. For product systems, read more of Evans, Vernon, and Newman. For infrastructure, read more of the SRE books, Release It!, and Database Internals.
  4. Read the original papers on the MIT 6.5840 schedule last. When you read GFS, Raft, or Spanner, compare the paper with the related chapter of DDIA. Find out where the conclusions of the book come from.

You do not need to read the pattern books in the fifth group from start to finish. Look up a pattern when you need it. If you have little time, read at least DDIA and Fundamentals of Software Architecture. If you have more time, do some of the MIT labs. Then you can talk about replication and consensus with more confidence.

References

Publisher pages, authors’ own pages, and course home pages are primary sources.

Data systems and distributed systems

Software architecture

Domain modeling and service boundaries

Reliability and operations

Classic patterns

Open course

↑ Back to top