Event Driven

Observer

Establishes a one-to-many dependency so that when one object changes state, all its dependents are notified and updated automatically.

Publish-Subscribe

Decouples senders from receivers by routing messages through a broker or channel so publishers and subscribers never reference each other.

Domain Event

Captures something significant that happened in the domain as an explicit object, decoupling the trigger from the reactions to it.

CQRS (Command Query Responsibility Segregation)

Separates the model that writes data (commands) from the model that reads it (queries) so each can be optimized independently.

Transactional Outbox

Reliably publishes messages by writing them to an outbox table in the same local transaction as the business data change.

Change Data Capture (CDC)

Captures row-level changes from a database's transaction log and streams them as events to downstream consumers.

Choreography

Coordinates a distributed workflow through services reacting to each other's events, with no central controller.

Competing Consumers

Enable multiple concurrent consumers to process messages from the same queue to increase throughput and improve resilience.

Queue-Based Load Leveling

Use a queue between tasks and a service to smooth intermittent heavy loads and protect the service from being overwhelmed.

Claim Check

Store a large message payload externally and pass only a reference through the messaging system to avoid moving bulky data.

Compensating Transaction

Undo the completed steps of a multi-step operation when one step fails, restoring consistency without distributed ACID transactions.

Sequential Convoy

Process related messages in order while still processing unrelated messages in parallel, by grouping them into ordered sets.

Message Channel

Connects two applications with a logical pipe so a sender can transmit data to a receiver without knowing the receiver's location or identity.

Point-to-Point Channel

Ensures exactly one receiver consumes each message on a channel, even when multiple consumers compete, so a message is processed once.

Publish-Subscribe Channel

Broadcasts each message to all interested subscribers so one event can notify many independent consumers without the publisher knowing them.

Message Router

Consumes a message and redirects it to a different channel based on conditions, decoupling producers from the decision of where messages should go.

Content-Based Router

Routes each message to a destination channel chosen by inspecting the message's content, so the payload itself determines where it is delivered.

Message Filter

Lets only messages meeting specified criteria pass through a channel and silently discards the rest, so consumers receive only relevant messages.

Splitter

Breaks a composite message into a series of individual messages so each element can be processed independently downstream.

Message Translator

Converts a message from one data format or schema to another so systems with incompatible representations can communicate.

Content Enricher

Augments a message with additional data from an external source when the original lacks information the receiver requires.

Polling Consumer

A consumer that explicitly checks a channel for messages on its own schedule, controlling exactly when and how fast it receives them.

Event-Driven Consumer

A consumer that is invoked by the messaging system the moment a message arrives, reacting to messages instead of polling for them.

Request-Reply

Lets a requestor send a message and receive a corresponding response over messaging, combining two one-way channels into a logical two-way exchange.

Correlation Identifier

Tags messages with a unique id that links related messages together, so a reply can be matched to its request and parts to their whole.

Wire Tap

Copies messages flowing through a channel to a secondary channel for inspection, logging, or analysis without disturbing the primary flow.

Routing Slip

Attaches a sequence of processing steps to a message so it routes itself through a series of components determined per message at runtime.

Process Manager

A central component that maintains the state of a multi-step message flow and decides the next step, coordinating complex or branching workflows.

Command Query Responsibility Segregation (CQRS)

Separates the write model that handles commands from the read model that serves queries, letting each be optimized, scaled, and evolved independently.

Event-Driven Architecture

An architectural style where components communicate by producing and reacting to events, enabling loose coupling, asynchronous flow, and independent scaling.

Lambda Architecture

A big-data design that runs a batch layer for accurate historical views and a speed layer for low-latency recent data, merging both at query time.

Kappa Architecture

A streaming-first data design that uses a single processing path over an immutable log, reprocessing history by replay instead of a separate batch layer.

Idempotent Writer

A pattern that makes repeated writes safe by ensuring duplicate operations produce the same result, essential for at-least-once delivery and retries.

Actor Model

A concurrency model where independent actors encapsulate state and communicate only by asynchronous messages, avoiding shared memory and locks.

Dead-Letter Queue

Routes messages that cannot be processed after repeated attempts to a separate queue for inspection and recovery, keeping the main pipeline flowing.

Poison Message Handling

Detects and quarantines messages that repeatedly crash or block a consumer, preventing one bad message from stalling an entire queue.

Webhook

A server pushes event notifications to a client-registered HTTP endpoint as events occur, replacing inefficient polling with real-time callbacks.

Anti-Patterns4

Entity Service

Designing microservices around data entities rather than business capabilities, forcing every workflow to orchestrate chatty calls across CRUD-only services.

Polling the Database

Repeatedly querying a table on a tight loop to detect changes instead of using events or notifications, wasting resources and adding latency.

Dual Write

Writing the same change to two systems in sequence without a single transaction or log, so a failure between them leaves the stores inconsistent.

Synchronous Call Chains

Deep chains of blocking request-response calls between services, so latency compounds and one slow or failed service cascades into widespread failure.

Tutorials6

Building Event-Driven Systems with Kafka

Create scalable event-driven architectures using Apache Kafka

How to decouple services with Amazon SQS

Use Amazon SQS queues to decouple producers and consumers, with dead-letter queues and Lambda triggers.

How to fan out events with Amazon SNS

Publish events to an Amazon SNS topic and fan them out to multiple SQS queues and Lambda subscribers.

How to route events with Amazon EventBridge

Build an event-driven workflow with Amazon EventBridge using event buses, rules, and pattern-based routing.

How to stream database changes with Debezium CDC

Capture row-level changes from PostgreSQL using Debezium and Kafka Connect, producing an ordered stream of insert, update, and delete events.

How to build a Kafka producer and consumer

Create a Kafka topic, produce messages with keys, and consume them in a group, covering offsets, partitions, and delivery basics.

Blueprints15

Django Monolith to Services Blueprint

Extract bounded capabilities from a large Django monolith into separate services with their own datastores and async messaging.

Scala Akka Actor Modernization Blueprint

Modernize legacy Scala Akka classic actor systems to typed actors and current streaming APIs while addressing licensing changes.

Synchronous REST to Event-Driven Blueprint

Convert tightly-coupled synchronous REST call chains into an event-driven architecture using a broker, async messaging, and the outbox pattern.

Single Database to Database-per-Service Blueprint

Decompose a shared monolithic database into per-service data stores to enable independent microservice deployment.

Batch to Streaming with Apache Kafka Blueprint

Replace nightly batch ETL with real-time event streaming on Apache Kafka for low-latency data movement.

Batch to Streaming with Amazon Kinesis Blueprint

Convert scheduled batch pipelines to real-time streaming on Amazon Kinesis Data Streams for managed, low-latency ingestion.

Build a Change Data Capture (CDC) Pipeline Blueprint

Stand up a CDC pipeline with Debezium and Kafka to stream database changes in real time to downstream consumers.

Synchronous Calls to Event-Driven (Kafka) Blueprint

Replace brittle synchronous service-to-service calls with asynchronous events on Apache Kafka to decouple services and improve resilience.

Synchronous API to SNS/SQS Fan-Out Blueprint

Decouple synchronous workloads using Amazon SNS topics and SQS queues for durable, buffered fan-out and asynchronous processing.

Point-to-Point Integrations to Message Bus Blueprint

Replace tangled point-to-point integrations with a central message bus and publish/subscribe model to reduce coupling and integration sprawl.

Enterprise Service Bus to Modern Integration Blueprint

Replace a heavyweight enterprise service bus with lightweight integration: API gateway, event streaming, and decentralized integration services.

Webhooks to Event Streaming Blueprint

Evolve unreliable HTTP webhook integrations into a durable event-streaming backbone with replay, ordering, and at-least-once delivery.

Central Orchestration to Choreography (Saga) Blueprint

Replace a central orchestrator coordinating distributed transactions with event-driven choreography using the saga pattern and compensations.

REST Polling to GraphQL Subscriptions Blueprint

Replace client REST polling for fresh data with real-time GraphQL subscriptions over WebSockets for push updates and lower load.

Batch File Transfer to Streaming CDC Blueprint

Replace nightly batch file transfers between systems with real-time change data capture streamed onto an event backbone.

Products5

Node.js

JavaScript runtime built on Chrome's V8 engine

AWS Lambda

Serverless compute service from Amazon Web Services

Azure Functions

Event-driven serverless compute on Azure

Google Cloud Functions

Event-driven serverless compute on Google Cloud

Apache Kafka

Distributed event streaming platform

Reference Architectures18

Event-Driven Microservices

Architecture pattern for building loosely-coupled microservices using event sourcing and CQRS

Event-Driven Microservices on Kubernetes

A Kubernetes-native reference design for loosely coupled microservices that communicate through Kafka events with service-level autoscaling.

Serverless API on Azure Functions

An event-driven serverless API built on Azure Functions with Cosmos DB and API Management for pay-per-use, low-operations workloads.

Serverless Event Processing Pipeline on AWS

A fully serverless event-ingestion and processing pipeline on AWS using Lambda, EventBridge, and DynamoDB with no servers to operate.

CQRS and Event Sourcing on Cloud

A cloud microservices design separating write and read models with event sourcing for full auditability and independent scaling.

Real-Time Streaming Platform with Kafka

A real-time streaming platform on Kafka with stream processing, a schema registry, and exactly-once pipelines on Kubernetes.

Computer Vision Inference Pipeline on Azure

A reference design for an image and video computer-vision pipeline on Azure spanning ingestion, GPU inference, and human-in-the-loop review.

Event-Driven Backbone with Kafka

An organization-wide event streaming backbone on Kafka that decouples producers and consumers through durable, replayable topics.

CQRS with Event Sourcing

A command-query separated system where state is derived from an append-only event log and read models are projected for queries.

Saga Orchestration for Distributed Transactions

An orchestrated saga design that coordinates multi-service business transactions with compensating actions instead of two-phase commit.

Reliable Webhook Delivery Platform

A platform that delivers outbound webhooks to customer endpoints with retries, signing, idempotency, and per-tenant rate control.

Pub/Sub Fan-Out for Event Distribution

A publish-subscribe fan-out architecture that broadcasts each event to many independent consumers with per-subscriber queues.

Real-Time Notification Delivery System

A real-time notification system that pushes in-app, push, email, and SMS messages to users with preference and channel routing.

Event Choreography for Microservices

A choreographed event-driven design where services react to each other's domain events without a central orchestrator.

Transactional Outbox for Reliable Events

A transactional outbox design that guarantees events are published exactly when their database changes commit, avoiding dual-write loss.

Real-Time Collaboration Application

A web app where many users edit shared documents concurrently, synchronized over WebSockets with conflict-free replicated data.

E-Commerce Platform on Microservices

A modular online store splitting catalog, cart, checkout, payments, and orders into independent services with event-driven coordination.

SaaS Usage Metering and Billing

An event-driven metering pipeline that records product usage, aggregates it per tenant, and drives usage-based billing.

Playbooks9

Domain-Driven Decomposition Program Playbook

A program that uses domain-driven design and event storming to decompose a system into bounded-context services aligned to teams.

Event-Driven Architecture Adoption Program Playbook

A program to introduce event-driven communication, a schema registry, and async workflows into a synchronous backend estate.

Batch to Streaming Program Playbook

Transform nightly batch data pipelines into real-time streaming pipelines using event-driven architecture and stream processing.

CDC and Real-Time Pipeline Program Playbook

Build change data capture pipelines to stream database changes into analytics and event systems with low latency and strong consistency.

Schema Evolution and Versioning Program Playbook

Adopt a schema registry and safe evolution practices for event and data schemas to prevent breaking changes across producers and consumers.

Event-Driven Architecture Adoption Playbook

A program to adopt event-driven architecture with a streaming backbone, schema governance, and resilient async patterns.

ESB to Modern Integration Playbook

A program to migrate from a centralized enterprise service bus to decentralized, event-driven and API-led integration.

Webhook Platform Rollout Playbook

A program to build a reliable webhook delivery platform with signing, retries, idempotency, and subscriber management.

AsyncAPI Messaging Standardization Playbook

A program to standardize asynchronous messaging contracts with AsyncAPI, schema governance, and contract testing across teams.

Checklists4

Event-Driven Architecture Readiness Checklist

Confirm readiness to adopt event-driven communication between services, covering schemas, delivery semantics, and observability.

Streaming Pipeline Readiness Checklist

Production-readiness checks for real-time streaming data pipelines built on platforms such as Apache Kafka or Pulsar.

Webhook Reliability Checklist

Verification items for delivering and consuming webhooks reliably, covering signing, retries, idempotency, and ordering.

Message Broker Migration Checklist

Migration items for moving messaging workloads to a new broker while preserving delivery guarantees and ordering.

Stacks10

Knative Serverless Containers Stack

Kubernetes-based serverless stack using Knative for scale-to-zero, request-driven container workloads with event-driven autoscaling.

AWS Serverless Stack

Fully managed AWS serverless stack using Lambda, DynamoDB, and API Gateway for event-driven, pay-per-use applications with no server management.

Azure Serverless Stack

Managed Microsoft Azure serverless stack using Azure Functions and Cosmos DB for event-driven, globally distributed, pay-per-use applications.

GCP Serverless Stack

Google Cloud serverless stack using Cloud Run and Firestore for container-based, scale-to-zero applications with managed NoSQL storage.

Kafka + Flink Streaming Stack

Real-time stream processing stack pairing Apache Kafka for durable event streams with Apache Flink for stateful, low-latency computation.

Event-Driven Microservices Stack

Asynchronous microservices architecture using Kafka as an event backbone with independently deployable services for loose coupling and scalability.

Dapr Distributed Application Stack

Polyglot microservices stack using Dapr building blocks for service invocation, state, pub/sub, and bindings, abstracted from underlying infrastructure.

Kafka + Flink + Iceberg Streaming Stack

Real-time streaming architecture: Kafka transports events, Flink processes them with stateful low-latency compute, and Iceberg lands them in an open lakehouse.

Vert.x Reactive Stack

A polyglot, event-driven toolkit on the JVM built around a non-blocking event loop and the reactor pattern for high-concurrency, low-latency services.

Kafka + ksqlDB

A stream-processing stack using Apache Kafka for event transport and ksqlDB for SQL-based streaming transformations and materialized views.

Comparisons5

Kafka vs RabbitMQ

Distributed event-streaming log versus a flexible, feature-rich message broker for traditional queuing.

Kafka vs Pulsar

Mature event-streaming standard versus Apache Pulsar's segmented storage and built-in multi-tenancy.

Spark vs Flink

The unified batch-and-streaming engine with micro-batch roots versus Apache Flink's true stream-first processing engine.

Pulsar vs Kinesis

Open-source, self-hostable streaming with built-in multi-tenancy versus AWS Kinesis, a fully managed streaming service on AWS.

OpenAPI vs AsyncAPI

OpenAPI describes synchronous request/response HTTP APIs; AsyncAPI describes event-driven, message-based APIs over brokers and streams.

FAQs4

What is serverless computing?

Serverless computing is a cloud model where the provider automatically provisions, scales, and manages the servers, so developers deploy code that run...

What is the difference between batch and stream processing?

Batch processing handles large volumes of data in scheduled chunks, such as a nightly job that aggregates the previous day's sales; it is simple and e...

What is a webhook?

A webhook is a way for one system to push real-time notifications to another by sending an HTTP POST to a URL the receiver registered in advance. Inst...