liveBook · Manning

Event-driven architecture

Also called EDA, event-driven design, event-driven approach

Event-driven architecture is a software architectural style in which components communicate and initiate processing by producing and responding to events.

How 14 Manning books explain it

Kafka for Architects

An event-driven system is a software system whose components react to events rather than relying primarily on direct synchronous interactions.

How it is used
Uses events to let services respond independently to state changes instead of relying on chains of synchronous calls.
How deep it goes
Defines the interaction pattern and examines reliability, consistency, and data-contract consequences without walking through client code.
Examples
Illustrates address-change notifications, independently reacting order services, and one order event serving inventory, payment, shipping, and analytics.
What you can do after
Evaluate/understand when asynchronous event delivery improves service independence and which consistency, delivery, and workload trade-offs need attention.

Read how Kafka for Architects explains event-driven architecture →

Effective Platform Engineering

Event architecture is a system design pattern in which components communicate and integrate through emitted and consumed events.

How it is used
Coordinates team onboarding, integration configuration, and distributed cluster deployments through published events.
How deep it goes
Explains publishers, subscribers, recurring synchronization, and scaling benefits without specifying event-stream implementation internals.
Examples
Uses team sync events for namespaces and integrations, plus GitHub webhook events that trigger cluster-level Helm upgrades.
What you can do after
Apply it via GitHub webhooks and Flux or ArgoCD to trigger cluster-level configuration changes.

Read how Effective Platform Engineering explains event-driven architecture →

Distributed Machine Learning Patterns

A processing architecture in which computation is initiated in response to incoming events or requests.

How it is used
Applies request-triggered processing to model serving with irregular or unpredictable traffic.
How deep it goes
Explains the request-to-prediction flow, shared resources, automatic scaling, and trade-offs against long-running serving.
Examples
Uses hotel price prediction queries, an unexpected pre-Christmas traffic spike, and a rate-limited queue of four requests.
What you can do after
Evaluate/understand when request-triggered model serving can reduce idle resources and provide real-time predictions.

Read how Distributed Machine Learning Patterns explains event-driven architecture →

Event Processing in Action

A way of designing and operating applications that use events directly or indirectly.

How it is used
Introduces an architectural style for applications whose components respond to event notifications.
How deep it goes
Defines producers, consumers, distribution, and intermediary processing, including their decoupling and potential to generate further events.
Examples
Illustrates distribution through asynchronous messages or a producer-written event log, alongside routing, filtering, and generation of events.
What you can do after
Evaluate event-driven designs by identifying producers, consumers, intermediary processing, and their relationships.

Read how Event Processing in Action explains event-driven architecture →

MongoDB 8.0 in Action, Third Edition

An event-driven application is an application whose components communicate and react through events rather than relying primarily on direct requests for data.

How it is used
Decouples services so they react to changes without repeatedly requesting updates from one another.
How deep it goes
Explains producer-to-platform-to-consumer flow and compares processing locations, but does not specify a complete application implementation.
Examples
Uses login, thermostat, and inventory changes as events, plus diagrams of point-to-point and streaming-platform communication.
What you can do after
Evaluate/understand when event-based communication and continuous stream processing address coupling, polling latency, and event-processing trade-offs.

Read how MongoDB 8.0 in Action, Third Edition explains event-driven architecture →

Architecture Modernization: Socio-technical alignment of software, strategy, and structure

An event-driven architecture is a software architecture in which components communicate and initiate processing through events.

How it is used
Uses event-driven patterns to reduce release, deployment, and testing dependencies while evolving architecture around business domains.
How deep it goes
Connects standardized patterns to decoupling and modularity, but stops short of implementation details or pattern selection guidance.
Examples
Uses La Redoute’s domain-aligned miniservices, standardized event-driven patterns, scalable test environments, and automated deployment tests.
What you can do after
Evaluate event-driven patterns against organizational constraints such as company size, release dependencies, deployment dependencies, and testing needs.

Read how Architecture Modernization: Socio-technical alignment of software, strategy, and structure explains event-driven architecture →

Software Architecture Decision-Making

Event-driven architecture is an architectural style in which components communicate and trigger work through events or messages.

How it is used
Frames event-driven architecture as a choice for independent evolution when direct coordination becomes costly.
How deep it goes
Explains operational and organizational failure modes, but does not provide an implementation tutorial.
Examples
Uses order processing, contrasting direct calls with an OrderPlaced event and independent consumers.
What you can do after
Evaluate/understand whether event-driven architecture improves extension and recovery without exceeding team operating capacity.

Read how Software Architecture Decision-Making explains event-driven architecture →

AI-Powered Developer: Build software with ChatGPT and Copilot

Event-driven architecture is a software architecture in which components communicate and react through events.

How it is used
Uses Kafka events to monitor asset movements and update inventory in real time.
How deep it goes
Explains local Kafka setup, topic commands, consumers, events, and mediator-based decoupling, but stops short of production operations.
Examples
Demonstrates asset_location topics, JSON location events, Docker Compose, Kafka commands, and an AssetLocationMediator.
What you can do after
Builds a local Kafka workflow and refines generated consumers to publish domain events without direct service coupling.

Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains event-driven architecture →

Learn Docker in a Month of Lunches, Second Edition

An event-driven architecture is a software design in which components publish events representing occurrences and other components react to those events.

How it is used
Uses message queues to add asynchronous features and decouple application components.
How deep it goes
Explains publishing, subscription, handler isolation, deployment, and scaling, but does not detail queue internals.
Examples
Demonstrates a to-do audit handler, SQL persistence, Elasticsearch indexing, Google Calendar reminders, and Docker Compose deployments.
What you can do after
Apply it by adding independent message handlers, scaling consumers, and deploying new asynchronous features without changing existing containers.

Read how Learn Docker in a Month of Lunches, Second Edition explains event-driven architecture →

Google Anthos in Action

Event-driven architecture is a software architecture in which components communicate and initiate processing through events.

How it is used
Orchestrates event-driven processing for Kubernetes services and supports external, predefined, or custom event sources.
How deep it goes
Explains Brokers, Triggers, sources, storage, scaling, and basic pipelines, while deferring complex event pipelines.
Examples
Uses Broker and Trigger manifests, a Cloud Pub/Sub source, and event flow diagrams as implementation examples.
What you can do after
Operate/configure Knative Eventing pipelines that route events from sources to scalable services.

Read how Google Anthos in Action explains event-driven architecture →

Grokking Software Architecture

A software architecture in which components communicate and trigger processing by producing and consuming events.

How it is used
Uses asynchronous events to decouple services in time and keep senders working when receivers are unavailable.
How deep it goes
Explains producer, broker, and consumer roles, code structure, and delivery safeguards, while keeping broker implementations behind an interface.
Examples
Uses an Order Service publishing OrderPlaced for a Shipping Service consumer, with a shared contract and shipping-label handler.
What you can do after
Understand how producers, brokers, and consumers keep services working independently despite delayed processing.

Read how Grokking Software Architecture explains event-driven architecture →

Apache Kafka in Action

Event-driven architecture is a software architecture in which components communicate by producing and consuming representations of events.

How it is used
Connects enterprise systems through asynchronously produced and consumed events, supporting near-real-time workflows and integration.
How deep it goes
Explains event representation, topic publication, subscription, asynchronous processing, benefits, and operational limitations without implementation commands.
Examples
Uses user interactions, system updates, financial transactions, Kafka topics, and legacy-to-modern enterprise integration as concrete examples.
What you can do after
Apply it via Kafka by publishing events to topics and having downstream services subscribe, process, and react asynchronously.

Read how Apache Kafka in Action explains event-driven architecture →

ActiveMQ in Action

An event-driven architecture is a software architecture in which components communicate and coordinate through events.

How it is used
Uses asynchronous messages to coordinate loosely coupled components and limit dependencies between them.
How deep it goes
Defines the architecture, explains its coupling benefits, and illustrates asynchronous stages without showing implementation details.
Examples
Uses an online order that proceeds through invoicing, payment, fulfillment, and shipping as separate stages.
What you can do after
Understand how asynchronous processing separates order acceptance from downstream service work.

Read how ActiveMQ in Action explains event-driven architecture →

Latency

Event-driven concurrency coordinates work by responding to events that signal changes or operation completions rather than blocking execution while waiting.

How it is used
Coordinates many I/O-bound operations through an event loop instead of assigning threads or blocking on each operation.
How deep it goes
Explains polling, dispatch, asynchronous continuation, and blocking constraints, but stops short of a complete implementation.
Examples
Uses a high-connection web server, asynchronous database queries, network buffers, timers, and operating-system I/O polling.
What you can do after
Apply it via an event loop that polls operating-system events and dispatches non-blocking handlers.

Read how Latency explains event-driven architecture →

Also covered in

What to know first

Related concepts

Questions about event-driven architecture

What is event-driven architecture?

Event-driven architecture is a software architectural style in which components communicate and initiate processing by producing and responding to events.

Which Manning books explain event-driven architecture?

Kafka for Architects, Effective Platform Engineering, Distributed Machine Learning Patterns, Event Processing in Action, MongoDB 8.0 in Action, Third Edition, Architecture Modernization: Socio-technical alignment of software, strategy, and structure, Software Architecture Decision-Making, AI-Powered Developer: Build software with ChatGPT and Copilot and 6 more.

What should I know before learning event-driven architecture?

Manning books that teach event-driven architecture usually introduce consistency, event, mean and message broker first.

What is the difference between event-driven architecture and request-response pattern?

Event-driven architecture is a software architectural style in which components communicate and initiate processing by producing and responding to events. A request-response pattern is a communication interaction in which one party sends a request and another returns a corresponding response.

What is event-driven architecture a kind of?

Event-driven architecture is a kind of design pattern. A design pattern is a reusable, general solution structure for a recurring software design problem.

What is event-driven architecture also called?

Event-driven architecture is also called EDA, event-driven design or event-driven approach.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.