System Design: Event-Driven Architecture (EDA)

Event-Driven Architecture (EDA) is about using events as a way to communicate within a system. Generally, leveraging a message broker to publish and consume events asynchronously. The publisher is unaware of who is consuming an event and the consumers are unaware of each other. Event-Driven Architecture is simply a way of achieving loose coupling between services within a system.

What is an event?

An event is a data point that represents state changes in a system. It doesn't specify what should happen and how the change should modify the system, it only notifies the system of a particular state change. When a user makes an action, they trigger an event.

Components

Event-driven architectures have three key components:

• Event producers: Publishes an event to the router.
• Event routers: Filters and pushes the events to consumers.
• Event consumers: Uses events to reflect changes in the system.

Note: Dots in the diagram represents different events in the system.

Patterns

There are several ways to implement the event-driven architecture, and which method we use depends on the use case but here are some common examples:

• Sagas
• Publish-Subscribe
• Event Sourcing
• Command and Query Responsibility Segregation (CQRS)

Note: Each of these methods is discussed separately.

Advantages

Let's discuss some advantages:

• Decoupled producers and consumers.
• Highly scalable and distributed.
• Easy to add new consumers.
• Improves agility.

Challenges

Here are some challenges of event-drive architecture:

• Guaranteed delivery.
• Error handling is difficult.
• Event-driven systems are complex in general.
• Exactly once, in-order processing of events.

Use cases

Below are some common use cases where event-driven architectures are beneficial:

• Metadata and metrics.
• Server and security logs.
• Integrating heterogeneous systems.
• Fanout and parallel processing.

Examples

Here are some widely used technologies for implementing event-driven architectures:

• NATS
• Apache Kafka
• Amazon EventBridge
• Amazon SNS
• Google PubSub

---

This article is part of my open source System Design Course available on Github.

karanpratapsingh / system-design

Learn how to design systems at scale and prepare for system design interviews

System Design

Hey, welcome to the course. I hope this course provides a great learning experience.

This course is also available on my website and as an ebook on leanpub. Please leave a ⭐ as motivation if this was helpful!

Table of contents

• Getting Started

  • What is system design?

• Chapter I

  • IP
  • OSI Model
  • TCP and UDP
  • Domain Name System (DNS)
  • Load Balancing
  • Clustering
  • Caching
  • Content Delivery Network (CDN)
  • Proxy
  • Availability
  • Scalability
  • Storage

• Chapter II

  • Databases and DBMS
  • SQL databases
  • NoSQL databases
  • SQL vs NoSQL databases
  • Database Replication
  • Indexes
  • Normalization and Denormalization
  • ACID and BASE consistency models
  • CAP theorem
  • PACELC Theorem
  • Transactions
  • Distributed Transactions
  • Sharding
  • Consistent Hashing
  • Database Federation

• Chapter III

  • N-tier architecture
  • Message Brokers
  • Message Queues
  • Publish-Subscribe
  • Enterprise Service Bus (ESB)
  • Monoliths and Microservices
  • Event-Driven Architecture (EDA)
  • Event Sourcing
  • Command and Query Responsibility Segregation (CQRS)
  • API Gateway
  • REST, GraphQL, gRPC
  • Long polling, WebSockets, Server-Sent Events (SSE)

• Chapter IV

  • …

View on GitHub