Three architecture books I keep handing to engineers

Clean Architecture: A Craftsman's Guide to Software Structure and Design

Uncle Bob strikes again! I had been waiting for this book for about a year, and had set high expectation. It ended up exceeding my expectations and providing value in areas of technical architecture I was completely oblivious about.

Discover what architecture is really about, and most importantly what it is not about. Learn the difference between architecturally critical elements and mere details. Get to know how important are layers and boundaries, and how to successfully define them. Brush up on numerous design principles for tackling function, component separation, and data management. Finally, become familiar with common architectural failures of the Industry, and figure out how prevent or face them.

Whether you are tasked with designing a new architecture or executing a design that someone else came up with, Clean Architecture is where you want to start from. It’s a pleasant read that I was able to finish cover to cover within just a few days. If you haven’t already, also check out the the other two book of the series, Clean Code (Amazon affiliate link) and The Clean Coder (Amazon affiliate link) (not prerequisites for reading Clean Architecture).

Building Microservices: Designing Fine-Grained Systems (2nd Edition)

Sam Newman’s tour of what changes when you move from a monolith to a network of smaller, self-contained services: deployment, communication, data ownership, testing, organizational design, and the failure modes none of those topics surface in isolation.

The 2nd edition (2021) updates the architecture chapters with lessons learned across the years since the 1st edition, and folds in modern patterns around platforms, observability, and team structure. It stays at the architectural level rather than diving into code, which makes it a relatively short read.

A good entry point if you’ve inherited a microservices system you didn’t design, or if you’re trying to decide whether to start one. Pair with Microservices Patterns for the implementation-level catalog.

Domain-Driven Design: Tackling Complexity in the Heart of Software

Eric Evans’ DDD is one of those books whose ideas have so thoroughly permeated the industry that people use the vocabulary (bounded context, aggregate, ubiquitous language) without realizing where it came from.

The blue book is dense, occasionally academic, and worth every page. Evans argues that the most expensive bugs are not in the code, they are in the model: the moment where the development team’s mental model of the business diverged from the business’s actual model. Everything downstream, the architecture, the database, the bugs, the rewrites, follows from that divergence.

A book that rewards a second reading once you have lived through a project where the model went wrong. If you ship software for a non-trivial business domain, this is required reading.

Release It! 2nd Edition

The title is a bit misleading. This book is not so much about the act of releasing software, but rather designing systems that you feel comfortable releasing.

It’s a common trap to design a system and focus only on the happy paths, but that’s only the first (and often easiest) step. Good software is reliable, resilient, and ready to overcome a series of difficulties that may arise.

The book is thought-provoking, engaging, and full of real-world experiences that can really change the way you think about delivering working software.

Building Evolutionary Architectures: Automated Software Governance (2nd Edition)

We conceived software as a vehicle for making the behavior of computers and machines easy to change. By producing software that’s hard to change we essentially beat the purpose of its very existence.

This book is a collection of patterns, anti-patterns, and advice, all emerged from years of Industry experience. It can help you not just to guide the evolution of software systems, but also contribute to their longevity.

Microservice Patterns: With examples in Java

Chris Richardson’s pattern catalog for microservices, covering the lifecycle from initial decomposition through API design, data management, deployment, and observability. Each pattern includes the trade-offs and the failure modes, not just the happy-path implementation.

The code examples are in Java but the patterns are framework-agnostic. The saga, transactional outbox, and CQRS chapters in particular apply to any stack.

A useful companion to Building Microservices and Designing Data-Intensive Applications for anyone designing distributed systems.

Designing Data-Intensive Applications, 2nd Edition: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems

This is an extremely valuable read, not only for architects, but also for those who work with microservices or any distributed application that revolves around data.

Today, data is in the heart of most challenges related to systems design. Architects have plenty of data-centric challenges to tackle, including scalability, consistency, reliability, efficiency, and maintainability. On top of that there are numerous platforms and tools that can be leveraged to achieve each project’s design goals, including relational / document / graph databases, stream / batch processors, web APIs and message brokers.

Martin Kleppmann doesn’t just help you make sense of the buzzwords. He guides you through the landscape with deep dives into how each piece of technology works under the hood, what its trade-offs are, and when it’s the right call. The book is part theory, part practical advice you can put to work the next morning.

The 1st edition (2017) is already a modern classic, cited everywhere serious people talk about systems. The 2nd edition (2025) brings it up to date: cloud-native data, the evolved streaming landscape, refreshed examples, and several years of accumulated criticism worked back in. If you only own one architecture book, own this one.