Some time ago I wrote a post on why every one of us should have our own library of software engineer books. The list was focused on the books that will help grow your software engineer career. In today's text I want to present a similar list, however this one focuses on software architecture books. Below, I will present eight software architecture books that will help you write simpler and better systems.
Software Architecture Books
I have already covered my motivation in-depth inside the previous post, so let's jump right to the best software architecture books.
Microservices Patterns
Microservices Patterns by Chris Richardson is one of my favourite software architecture books overall. It is a great introduction to the world of microservices, but it's also a good read if you have more experience. This book will give you some more theoretical insight into how and why things work the way they work. The author describes the most common problems in the microservice environment and patterns that we may use to solve them.
The book will be especially great for people with experience in Java because all code snippets inside are written using Java. After finally reading it, I regret that I didn't do it earlier. Even if you are in the process of reading another book already, you can add this one to your "to read" list – better sooner than later, trust me, it will pay off. The author also runs his own blog, https://microservices.io/, where you can find lots of valuable information.
What is more, the 2nd edition of the book is already here, at least in Manning Early Access Program format. If it is at least as good as the first edition I would recommend grabbing your own copy right away.
System Design Interview
System Design Interview – An insider’s guide by Alex Xu, is probably the simplest, and most easily laid-out intro to system design and/or architecture I have seen for a long time. Besides that, it also provides some insight into how some of the systems we use in our everyday life actually work.
In addition to obvious interview tips, like back-of-the-envelope estimates or a framework for approaching the interview itself. It also gives a lot of useful information on how to scale your system, and introduces quite interesting concepts like consistent hashing, different rate-limiting algorithms, proximity algorithms. You know, the things that you would rather not meet in day-to-day work. Unless you work in a very specific domain.
I strongly recommend reading it even if you are not actively preparing for an interview. I am sure it will be time well spent, besides it is also quite pleasant to read. There is also a second edition of this book; however, I recommend starting with the first one, as the second edition sometimes mentions concepts introduced in the first one.
Reactive Design Patterns
Reactive Design Patterns by Roland Kuhn and Jamie Allen is an excellent extension to the Richardson's Microservices Patterns and/or vice versa. It explores the same topics as Richardson's book but from a different angle. It introduces and analyses a few new patterns compared to the previous book, for example Bulkhead or Error Kernel patterns.
It is not as famous as Microservices Patterns but nevertheless I believe it is also a worthy read. It will deepen your knowledge on how to approach problems in software architecture or fill some gaps you may not know exist. Just be aware that it has examples in Scala not only in Java, so it may seem somewhat hard from time to time. On the other hand some of you may view it as a pro not a problem.
Designing Data-Intensive Applications
Designing Data-Intensive Applications by Martin Kleppmann PhD. is probably the most famous software architecture book currently available. There is even a meme about everyone having and not reading it. It is a great in-depth overview of some of the most complex topics we may encounter in our work. Starting from relatively simple things like data storage and processing format through Replication and Partitioning to Stream processing.
In my opinion it is hard to find another such diverse and in-depth book on distributed systems. The book is also enriched with author views on possible future landscape of distributed systems. All of this combined with the author's reputation as a leading figure in the distributed systems world makes this book even more interesting.
There is also a new edition of this book, albeit in Early Access, so you can start there right away. It is a solid portion of technical knowledge with a great potential to fry your brain out while reading.
Streaming Systems
Streaming Systems: The What, Where, When, and How of Large-Scale Data Processing by Tyler Akidau, Slava Chernyak, Reuven Lax is the newest addition to my reading-done list. From my research before buying this book, it is a kind of universally recommended book for anyone looking to understand how streaming systems work under the hood.
While most coding examples in the book are based on Apache Beam, which should not be surprising given the author, it was not a problem to understand them right away. Even for me, the person with almost no prior exposure to Beam.
The book explores in-depth the topics like: windowing, watermarking, Streaming SQL and a few others. All the chapters follow What, Where, When, and How structure, making it easier to put together how all the things are connected and how they work together.
While the book may seem a little dated, released in 2018, most if not all concepts described inside are still valid. They are very low level, and probably will not change on a conceptual level for a long time.
Fundamentals of Software Architecture & Software Architecture: The Hard Parts
In this section I want to cover two software architecture books which I treat as a series. Both have the same set of main authors, Neal Ford, Mark Richards, and are focused around the same set of topics, with the second one being a logical continuation of the first, at least in my opinion.
The books in question are:
- Fundamentals of Software Architecture: An Engineering Approach
- Software Architecture: The Hard Parts: Modern Trade-Off Analyses for Distributed Architectures
The first book describes core traits each software architecture has. It also dives into the challenges in building systems. The most interesting part of this book is a deep comparison of multiple software architecture styles along the set of axes. This set is pretty extensive and numbers more than 10 different traits.
The second book – Software Architecture: The Hard Parts – describes how to work with different trade-off, when and how to apply a particular architectural pattern. This makes both books a great series with one filling gaps and deepening your knowledge from reading the second.
Building Microservices
Building Microservices: Designing Fine-Grained Systems by Sam Newman is a recommendation from my teammates. I have never read this book myself, however I have heard a lot of good things about this book from more than one person. They say it is insightful and well-written – a great resource, especially for those new to microservices.
After making a quick skim throughout its pages I fully agree with their statements. It most certainly looks like a good and insightful read. However, I still prefer the Microservices Patterns. Maybe it would change if I read the full book, but this will not happen in the near future.
Implementing Domain-Driven Design
This list would not be complete without at least one software design book focused on Domain-Driven Design. This place belongs to Implementing Domain-Driven Design by Vaughn Vernon the famous DDD "Red Book". I have actually read both the "Red Book" and the "Blue Book" of Domain-Driven Design. Implementing Domain-Driven Design suited me much more, it feels more clear and easier to read.
This book covers all you need to know about DDD. Starting from strategic patterns (bounded contexts, context maps) to tactical implementation (aggregates, repositories, factories, domain events). The author also spends a lot of time on invariants, consistency boundaries, and how to collaborate across services with messaging/CQRS. Exactly the place where most teams stumble.
Taking into account that both the "Red Book" and the "Blue Book" are focused on the same topics I prefer to recommend the one that suited me better.
Patterns of Enterprise Application Architecture
At last, I have Patterns of Enterprise Application Architecture by Martin Fowler.
This one is a more honorable recommendation due to its impact on software architecture as a whole than anything else.
The problems and patterns (layering, mapping to databases, presentation) described inside remain virtually unchanged since the book's publication. However, currently we have a whole set of well known tools that can address each of the problems from the book. The patterns on the other hand are widely adopted as best practices or just industry-wide standards to handle particular problems.
Do not get me wrong, it is still a good book, and may be interesting. It is just somewhat outdated. This is also the only software architecture book here I did not read fully. I have only skimmed through the pages to get the most interesting parts. It was somewhat interesting and insightful, but I would rather not repeat it. Nevertheless, it may work in a different way for you.
Software Architecture Books – Summary
These software architecture books cover everything from system design fundamentals to advanced distributed systems and microservices. Whether you're a junior developer or a seasoned architect, building a personal library of software architecture resources can significantly boost your technical decision-making and long-term career success.
Below, you can see the table with the order in which I recommend reading the software architecture books from above. Of course, do not be afraid to change it as you see fit; it is just written, not set in stone.
| # | Book | Why/When |
|---|---|---|
| 1 | System Design Interview (Vol. 1–2) | Fast primer on trade-offs & scale; interview or onboarding. |
| 2 | Microservices Patterns | Core patterns for distributed services. |
| 3 | Reactive Design Patterns | Fault-tolerance & resilience angle |
| 4 | Designing Data-Intensive Applications | Deep dive into storage, replication, streams. |
| 5 | Fundamentals of SA → The Hard Parts | Architecture styles + trade-off playbook. |
| 6 | Building Microservices | Field guide to doing microservices well. |
| 7 | Implementing Domain-Driven Design | Extensive intro into Domain-Driven Design |
| 8 | Patterns of Enterprise Application Architecture | Historical patterns; skim for timeless ideas. |
Thank you for your time.
Might interest you: