Skip to content

CONCEPT Cited by 4 sources

Event-driven architecture

Event-driven architecture (EDA) is a software-system style in which services communicate asynchronously by publishing and subscribing to events on a shared bus — not by direct synchronous request/response. Producers don't know which consumers will process an event; consumers control their own queue depth, retention, and processing semantics.

Primitives

  • Event — an immutable record that something happened (OrderPlaced, AccessGranted, DeliveryDispatched). Has a schema, timestamp, and publisher identity.
  • Event bus — the shared substrate routing events to subscribers. AWS's managed offering is systems/amazon-eventbridge.
  • Publisher — any service that emits events. Knows the bus, not the consumers.
  • Subscriber — any service that consumes events matching a filter rule. Decides its own retry / DLQ / processing guarantees.
  • Routing rule — pattern-based filter matching events to subscribers; in EventBridge the rule language is a content-based JSON pattern.

Why shift to EDA

The core failure mode of tightly-coupled synchronous architectures is the cascade: a downstream slowness or outage propagates upstream as timeouts, retries amplify load, and the system deadlocks. Amazon Key's pre-migration architecture explicitly exhibited this — "an issue in Service-A triggered a cascade of failures across many upstream services, with increased timeouts leading to retry attempts and ultimately resulting in service deadlocks". Blast radius was arbitrary: a single-device-vendor issue scoped to one delivery operation caused fleet-wide degradation.

EDA isolates the cascade:

  • Publisher doesn't wait for the consumer. If the consumer is slow or down, events queue.
  • Consumer failures don't amplify load on the publisher.
  • Per-subscriber queue + retry + DLQ policies contain the blast radius to a single consumer.
  • New consumers are additive: they attach a rule + a target without modifying the publisher.

(Source: sources/2026-02-04-aws-amazon-key-eventbridge-event-driven-architecture)

What EDA costs you

  • Schema governance moves from implicit to explicit. Ad-hoc pub/sub on SNS/SQS without a schema registry produces un-versioned contracts that become impossible to evolve — no place to remove unused fields safely, no way for publishers to detect invalid events before publishing, no audit trail. This is the problem Amazon Key's custom schema repository addresses.
  • Debugging goes multi-system. No single stack trace across producer → bus → N consumers; observability must correlate events via IDs.
  • "Exactly once" is not free. Consumers must be idempotent because at-least-once is the default message-delivery guarantee on most managed buses.
  • Operational surface grows. Per-subscriber IaC scaffolding (dedicated event bus + IAM + monitoring + alerting) can be standardised via patterns/reusable-subscriber-constructs to keep this tax bounded.

Seen in

Last updated · 200 distilled / 1,178 read