Building Event-Driven Microservices - book review
Posted on 22 November 2026 in Articles • 3 min read
All my life I've been building synchronous microservices, which worked great for the problems at hand. This year I faced different challenges and had to dive deep into event-driven architecture. "Building Event-Driven Microservices" by Adam Bellemare helped me to solidify my knowledge and take me further.
I didn't read this book solely out of pure interest. Simply put: I hit the limits of synchronous microservices communication. I am shipping the end-user -facing applications services. I'm proud of my services' response times. Then comes a new feature request. It requires data from deep upstream. Guess what, the only provider of that data can't tolerate the load of my service. Is some hacky fragile database integration pattern the only way to overcome this?
Business flows are tricky in organisations with hundreds of internal and external applications. A business capability may spawn across multiple applications owned by different teams and different parts of the organisation. A simple change (like "displaying a user's birthday on a page") can take months to implement, not because it's technically hard, but because the origin of the data is five layers below, and every team on the way needs to wait for the one below them to finish first.
Quite often this happens because the data you need is too far away, not just in engineering, but also in business terms. The teams can be scattered across the organisation with their own agendas and priorities. You try to start consuming directly from the bottom layer only to find out that it exposes data only through a legacy interface, and the mid-layers abstract it in too mysterious ways.
But what if there was a way for the services to expose their streams of business events? What if consuming these streams would not affect the services at all, and every consumer can combine and materialise these streams in a unique manner tailored to their needs?
In "Building Event-Driven Microservices" Adam Bellemare takes you through on this journey and guides you to see beyond the synchronous request-response communication. He starts by explaining the benefits of an event-streaming communication that decouples the production and ownership of data from its access. And then it changes your world upside down!
The biggest shock was when I understood that Events are data in its full representation, not merely signals indicating that data is now available elsewhere. They are both data storage and a means of asynchronous communication between services. Thus, given an immutable and durable event log, a service that exposes the current state to a generic consumer is not necessary anymore! Which in turn means that service-to-service coupling evaporates (and transforms to somewhere else :)
Aligning bounded contexts on business requirements allows teams to make changes to microservice implementations in a loosely coupled and highly cohesive way. It provides a team with the autonomy to design and implement a solution for the specific business needs, which greatly reduces interteam dependencies and enables each team to focus strictly on its own requirements.
—Adam Bellemare, "Building Event-Driven Microservices"
The "something else" is an Event Broker - the heart of event-driven microservices architecture. This is a system that receives events, stores them in a queue or partitioned event stream, and provides them for consumption by other processes. For a broker, Scalability, Durability, High availability and High-performance are not just desirable - the whole concept is built with these essential features in mind.
From here on the book takes you deeper through all the whats?, hows? and whens?. It starts with the hardest part - integrating Event-Driven Architectures with existing systems and examines ways of Liberating Data - making the necessary business domain data available in the event broker, consumable as event streams. Next is Stream Processing. How to set up underlying infrastructure efficiently to process events in parallel. How to branch and merge streams. How to synchronise and handle out-of-order events and the caveats of materialising streams. The following chapters are about building event-driven workflows with microservices and the technical aspects - frameworks, tools, testing and deployment practices.
I'm very glad that I read this book. I would have loved to see more detailed examples on every described case - but then this could easily double the amount of pages :). Even if your architecture implies synchronous communication, don't limit your knowledge and skills. This is a great book to dive into Event-Driven Microservices!