Store State as an Event Log with Event Sourcing
Store State as an Event Log with Event Sourcing — Event sourcing flips how you think about state. Instead of storing the current state of something, y.
Event Driven Articles
50 articles
Build or Choose an Event Store for Event Sourcing
The most surprising truth about event stores is that they're not just databases for events; they're the time machine for your application's state.
Stream Events at Scale with Kafka in Event-Driven Architectures
Kafka is fundamentally a distributed commit log, not a message queue, and that difference is the key to its ability to handle event streams at scale.
Achieve Exactly-Once Event Processing Without Duplicates
The most counterintuitive truth about achieving exactly-once event processing is that it doesn't actually guarantee zero duplicates; it guarantees zero .
Distribute One Event to Multiple Consumers with Fan-Out Pattern
The "fan-out" pattern isn't just about sending one message to many listeners; it's fundamentally about decoupling the event producer from the event cons.
Build Event-Driven Systems on GCP with Cloud Pub/Sub
Cloud Pub/Sub is surprisingly bad at reliably delivering messages to all subscribers simultaneously, and that's precisely why it's so good at building e.
Make Event Handlers Idempotent to Survive Duplicate Delivery
A surprising truth about event-driven systems is that, by design, they are inherently unreliable. Let's see what that means in practice
Reliably Consume Events with the Transactional Inbox Pattern
The Transactional Inbox pattern is a clever way to ensure that event consumers don't lose messages, even if they crash halfway through processing.
Share State Across Microservices with Integration Events
Share State Across Microservices with Integration Events — practical guide covering event-driven setup, configuration, and troubleshooting with real-wor...
Build Reliable Kafka Consumers for Event-Driven Systems
Build Reliable Kafka Consumers for Event-Driven Systems — practical guide covering event-driven setup, configuration, and troubleshooting with real-worl...
Route and Queue Events with RabbitMQ in Event-Driven Systems
RabbitMQ doesn't queue events; it routes messages that represent events to queues, and consumers then process those messages.
Event-Driven Microservices Patterns: Choreography and Orchestration
Microservices can coordinate their actions in two fundamentally different ways, and understanding the difference is crucial for building robust, scalabl.
Observe Event-Driven Systems: Tracing, Metrics, and Logging
Observe Event-Driven Systems: Tracing, Metrics, and Logging — practical guide covering event-driven setup, configuration, and troubleshooting with real-...
Guarantee Event Ordering Across Partitions and Consumers
The only way to guarantee event ordering across all consumers for a given event type is to ensure that all events of that type are routed to a single pa.
Publish Events Reliably with the Transactional Outbox Pattern
The transactional outbox pattern is a way to guarantee that an event published by your application is either successfully saved to your database and sen.
Partition Events by Key to Preserve Order and Scale
When you partition events by key, you're essentially ensuring that all events associated with a specific identifier like a user ID, session ID, or devic.
Event-Driven Patterns Complete Guide: From Pub/Sub to Saga
Event-driven architectures aren't just about decoupling services; they're fundamentally about managing state transitions across distributed systems in a.
Tune Event-Driven Systems for High Throughput and Low Latency
The core reason event-driven systems feel slow is usually because their internal queues are backing up, not because the individual events are taking a l.
Test Event Producers to Verify Correct Event Publishing
The fundamental purpose of an event producer is to reliably get an event from point A your application to point B the event bus.
Design Production Event-Driven Architecture for Reliability
Event-driven architecture is fundamentally a distributed system design that prioritizes loose coupling and asynchronous communication to achieve resilie.
Process Events for Real-Time Analytics Pipelines
The core problem with real-time analytics is that the data is never truly "real-time" without a system that can process events as they happen, not in ba.
Retry Failed Events with Backoff and Circuit Breakers
A surprising number of systems that appear to be failing are actually just overloaded, and the most effective way to handle this is to deliberately slow.
Coordinate Distributed Transactions with Saga Choreography
A distributed transaction is not a single atomic operation; it's a series of independent, observable operations that appear atomic to the user.
Orchestrate Distributed Sagas with a Central Coordinator
A saga is a sequence of local transactions where each transaction updates data within a single service and publishes a message or event to trigger the n.
Scale Event-Driven Systems: Partitioning, Sharding, and Fan-Out
Event-driven systems scale by distributing the processing of events across multiple instances. This is achieved through partitioning, sharding, and fan-.
Evolve Event Schemas Without Breaking Existing Consumers
The most surprising truth about evolving event schemas is that you can usually break the "never break consumers" rule – you just have to break it smartl.
Secure Event-Driven Systems: Auth, Encryption, and Auditing
Event-driven systems are often treated as ephemeral, but their security needs are as concrete and critical as any request-response API.
Trigger Serverless Functions from Events in AWS, GCP, and Azure
Serverless functions, at their core, are event-driven automatons, but the systems that trigger them are often more complex than they appear.
Decouple Services in Time with Async Event-Driven Architecture
Decouple Services in Time with Async Event-Driven Architecture — practical guide covering event-driven setup, configuration, and troubleshooting with re...
Test Event-Driven Systems End-to-End Without Mocking Everything
The most surprising thing about testing event-driven systems end-to-end without mocking is that you can achieve high confidence by focusing on the inter.
Debug Event-Driven Systems by Replaying Historical Events
Replaying historical events in an event-driven system isn't just about debugging; it's the closest you'll get to time travel for your application logic.
Version Events to Add Fields Without Breaking Consumers
Version Events to Add Fields Without Breaking Consumers — practical guide covering event-driven setup, configuration, and troubleshooting with real-worl...
Event-Driven vs Request-Response: Choose the Right Model
Event-driven architectures are often pitched as the modern, scalable way to build systems, but the truth is, they're just a different way of managing st.
Aggregate Events from Multiple Sources with the Aggregation Pattern
The most surprising thing about event aggregation is that it's often not about collecting events, but about discarding them until you have something mea.
Event-Driven Anti-Patterns That Will Hurt You in Production
The most surprising thing about event-driven systems is how easily they can become a distributed monolith, locking you into tight coupling disguised as .
Event-Driven Architecture Explained: Events, Brokers, and Consumers
Event-driven architecture EDA is fundamentally about decoupling services by having them react to state changes rather than directly calling each other.
Build Event-Driven Systems on AWS with EventBridge
Build Event-Driven Systems on AWS with EventBridge — practical guide covering event-driven setup, configuration, and troubleshooting with real-world exa...
Trigger Serverless Workflows on Azure with Event Grid
Azure Event Grid is the glue that lets you connect disparate Azure services, and when you want to kick off an Azure Logic App or Azure Functions workflo.
Handle Backpressure in Event-Driven Systems Without Data Loss
Event-driven systems can gracefully handle situations where producers generate events faster than consumers can process them, preventing data loss by em.
Capture Database Changes as Events with Debezium CDC
Debezium doesn't just read database changes; it transforms them into a stream of immutable events that can be processed by other systems.
Scale Event Consumers Horizontally with Consumer Groups
The most surprising thing about scaling event consumers horizontally with consumer groups is that it fundamentally changes how events are delivered, mov.
Test Event Consumers Without a Running Broker
You can test event consumers without a running Kafka broker by using an embedded Kafka broker. This is how you can spin up an embedded Kafka broker and .
Prevent Breaking Changes with Event-Driven Contract Testing
Contract testing is your best friend for preventing breaking changes in event-driven systems, and the most surprising thing is how little it actually te.
Connect CQRS Read and Write Sides with Domain Events
CQRS is often pitched as a way to separate your read and write models, but the real magic happens when that separation allows your write side to publish.
Handle Unprocessable Events with Dead Letter Queues
The most surprising thing about Dead Letter Queues DLQs is that they aren't primarily for dead events, but for sick ones that need attention.
Trace Requests Across Event-Driven Services
Tracing requests across event-driven services is less about tracking a single request and more about reconstructing a story from fragmented conversation.
Model Business State Changes as Domain Events
Model Business State Changes as Domain Events — practical guide covering event-driven setup, configuration, and troubleshooting with real-world examples.
Document and Discover Events with a Service Event Catalog
A service event catalog isn't just a list of events; it's the operational memory of your distributed system, allowing you to understand what's happening.
Replay Past Events to Rebuild State or Reprocess Failures
The most surprising thing about replaying past events is that it's often the only way to reliably rebuild your system's state after a disaster.
Enforce Event Schemas with a Central Schema Registry
The most surprising thing about enforcing event schemas is that you're not actually enforcing them everywhere – you're enforcing them at the seams of yo.