Event-driven architecture
Event-driven architecture is a software architectural style in which components communicate or 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 →
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.
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 →
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 →
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.
Related concepts
- design patternkind of · A design pattern is a reusable, general solution structure for a recurring software design problem in a particular context.
- eventuses · An event is an occurrence, change, or associated record or notification recognized as significant within a system or context.
- Apache Kafkauses · Apache Kafka is a distributed event-streaming platform for publishing, storing, processing, and consuming streams of records.
- asynchronous programminguses · Asynchronous programming is an execution approach in which operations can progress independently without requiring the initiating flow to wait for their completion or an immediate response.
- message brokeruses · A message broker is intermediary software that receives, routes, and delivers messages between communicating producers and consumers.
- request-response APIcontrasts with · A request-response API is an interaction pattern in which a requester sends a request to a provider and receives a corresponding response.
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.