Goal
The path to "Microservices Patterns"
Here is the reading path leading up to this book, derived from its dependencies and ordered from the fundamentals.
The path so far (14 books)
Why read this first: Once you can write basic Java syntax, the next step is to raise your sights from merely working code to code that is readable and easy to change. Clean Code provides principles for naming, function decomposition, and comments—building the sense of quality that is hard to acquire on your own.
Why read this first: After grasping how networks work, you descend to the OS layer that actually handles that communication. Linux system programming introduces the APIs—sockets, processes, file descriptors—on which servers run, bridging protocol and implementation.
Why read this first: Once you can do basic system programming in Go, you dig deep into concurrency—Go's greatest strength. Concurrency in Go systematizes the design of coordinating 'by communicating rather than sharing memory' using goroutines and channels, teaching how to build safe concurrent programs.
Why read this first: Having understood concurrency within a single process, you extend to a world where multiple processes—services—coordinate asynchronously. Microservices Patterns provides coordination patterns for distributed systems—messaging, sagas, event-driven design—extending the idea of concurrency across the network.
Why read this first: Knowing the OS-level mechanisms for processes, I/O, and memory lets you see what Spring abstracts away under the hood. This low-level understanding keeps the framework from being a black box and pays off when diagnosing performance issues and failures.
Why read this first: After grasping the basics of readability such as naming and function decomposition, you move on to binding them into principles of why. Clean Code connects individual techniques into a coherent system of craftsmanship and design principles.
Why read this first: After adopting the pragmatic mindset of keeping code healthy, you ground those attitudes in concrete quality standards at the function and class level. Clean Code systematizes what good code is through principles and worked examples.
Why read this first: Once you can write clean functions and classes, it's time to learn design patterns—named solutions to recurring design problems—through Java code. This book lets you experience the 23 GoF patterns in Java implementations, building a vocabulary of reusable designs and the ability to compose relationships between classes with clear intent.
Why read this first: Once you can wield class-level patterns, you broaden your view to how dependencies and boundaries are designed across the whole system. Clean Architecture offers the Dependency Rule—pushing details outward and keeping business rules at the center.
Why read this first: Once you can build applications with Spring, you start to feel the limits of framework-driven design centered on the database or the framework. Clean Architecture provides the Dependency Rule that keeps business rules independent of the framework, letting you choose a structure resilient to change over the long term.
Why read this first: Once you can design boundaries inside a system, you face the next decision: whether to split those boundaries into separate processes—services. Monolith to Microservices, guided by the pragmatic 'monolith first' principle, systematizes the motivations, methods, and pitfalls of decomposition.
Why read this first: Once you can decide whether to split a monolith, you stock up on the implementation patterns needed after the split. Microservices Patterns catalogs the established practices for service decomposition, data management, communication, and deployment, bridging from 'how to divide' to 'how to build.'
Why read this first: Patterns of Enterprise Application Architecture deals with how to layer an enterprise application, organize its domain logic and map objects onto a relational database. Enterprise Integration Patterns takes up what comes next: connecting such applications to each other through asynchronous messaging, in 65 patterns. The two share a way of presenting patterns as a catalog, so the reading habits built on the first book carry over.
Why read this first: Enterprise Integration Patterns organizes messaging channels, message construction, routing, transformation and endpoints with a vocabulary and a visual notation that do not depend on a product. Microservices Patterns takes up the problems that appear once a monolith is decomposed into services: interprocess communication between them, and transactions that span them, handled with sagas. With the messaging vocabulary of the first book in place, the second book's discussion of asynchronous communication can be followed from the ground up.