Event-driven architecture
Event-driven architecture is a software architectural style in which components communicate and initiate processing by producing and responding to events.
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.
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.
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.
Also covered in
- Troubleshooting Java, Second Edition
- BDD in Action, Second Edition
- Spring Microservices in Action
- Logs and Telemetry
- Platform Engineering on Kubernetes
- The Design of Web APIs, Second Edition
- Akka in Action, Second Edition
- Knowledge Graphs and LLMs in Action
- Learn AI Data EngineeringIn early access (MEAP)
- Grokking Concurrency
- Simple Object-Oriented Design: Create clean, maintainable applications
- Contract Testing in Action
What to know first
- consistencyConsistency is the degree to which related data, behavior, or results agree with one another and conform to applicable rules or expectations.
- eventA software event is an occurrence, state change, or notification that a system can detect, record, communicate, or handle.
- meanThe mean is a measure of central location equal to the arithmetic average of numerical observations, or the probability-weighted average of a random variable’s possible values.
- message brokerA message broker is intermediary software that receives, routes, and delivers messages between communicating components or systems.
Related concepts
- design patternkind of · A design pattern is a reusable, general solution structure for a recurring software design problem.
- eventuses · A software event is an occurrence, state change, or notification that a system can detect, record, communicate, or handle.
- Apache Kafkauses · Apache Kafka is a distributed event-streaming platform for publishing, storing, and processing streams of records.
- asynchronous programminguses · Asynchronous programming structures operations so that the initiating execution can continue or yield control without synchronously waiting for each operation to complete.
- request-response patterncontrasts with · A request-response pattern is a communication interaction in which one party sends a request and another returns a corresponding response.
- message brokeruses · A message broker is intermediary software that receives, routes, and delivers messages between communicating components or systems.
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.













