EDA Archives

Inbox & Outbox patterns for reliable event processing

AWS, Event-Driven Architecture, EventBridge, Serverless

Modern applications rarely do just one thing at a time.

An API request creates an order, and then another service needs to reserve stock, another to charge the customer, another to send an email, and so on. In a serverless or event-driven architecture, follow-up actions are usually triggered by messages (either events or commands).

The Inbox and Outbox patterns are often used together to build reliable event processing flows.

Outbox Pattern: ensure state changes reliably produce events.
Inbox Pattern: ensure incoming events are processed safely, even when they are delivered multiple times.

Understanding push vs poll in event-driven architectures

AWS, Event-Driven Architecture, EventBridge, Kinesis, Lambda, Serverless, SNS

When we talk about event-driven architectures, we often focus on things like loose coupling, scalability and DDD. But under the hood, the way consumers receive events matters just as much. And it usually comes down to one of two models: push vs poll.

Your choice dictates what service(s) you use and how you handle errors.

So, in this article, let’s compare the two models and understand their pros & cons.

Bye bye schema coupling, hello semantic coupling

Event-Driven Architecture

What if you don’t have to worry about event versioning or catching breaking changes anymore?

What if event consumers are no longer coupled to the schema of the event and instead, subscribe to their semantics?

I discovered an exciting new way to manage event schemas that will blow your mind!

How to detect and prevent breaking changes in event schemas

AWS, Event-Driven Architecture

How can you prevent accidental breaking changes from creeping into your event schemas?

You can detect and stop breaking changes:
* At runtime, when the events are ingested;
* During development, when schema changes are made;
* Or a combination of both!

In this article, let’s look at three approaches you should consider.

Event versioning strategies for event-driven architectures

Event-Driven Architecture, EventBridge, Serverless

Event-driven architectures encourage loose coupling.

But we are still bound by lessor forms of coupling such as schema coupling. And here lies a question that many students and clients have asked me:

“How do I version my event schemas?”

In this post, let’s run through some common approaches and why they all suck to some degree and the two most important decisions you need to make.

When to use Light Events vs. Rich Events in Event-Driven Architectures

AWS, Event-Driven Architecture, EventBridge

One under-appreciated aspect of designing an Event-Driven Architecture (EDA) is how much information you should include in your events.

Do you send light events or rich events?

Or perhaps you would send both, but in different circumstances?

In this post, let’s talk about the pros & cons of each and how they fit into my mental model of DDD and EDA.

EventBridge best practice: why you should wrap events in event envelopes

AWS, Event-Driven Architecture, EventBridge

This article is about best practices for building event-driven architectures on AWS, with a focus on wrapping events in custom envelopes when using EventBridge.

While EventBridge provides metadata by default, a custom envelope allows for a standardized, consistent structure across all of your events, making it easier to manage and evolve the system over time.

By providing your own metadata, you can gain better interoperability between different services, end-to-end observability, idempotency control and versioning.