Amazon EventBridge: What It Is and When to Use It

Definition

Amazon EventBridge is AWS's serverless event bus service. It routes events — small JSON documents describing something that happened — from sources (AWS services, your applications, SaaS partners) to targets (Lambda, SQS, SNS, Step Functions, Kinesis, ECS, API destinations, and more) based on rules that match event patterns or schedules. Originally launched in 2019 as a rebranded and extended version of CloudWatch Events, EventBridge is now the recommended way to build event-driven architectures on AWS. It also powers EventBridge Pipes (point-to-point streaming) and EventBridge Scheduler (managed cron at scale).

How It Works

Event buses

Every account gets a default event bus that receives events from AWS services (EC2 state changes, S3 events routed through it, CodePipeline transitions, etc.). You can also create custom event buses for your own applications, and partner event buses that receive events from SaaS partners (Auth0, Datadog, Zendesk, Shopify, Stripe, GitHub, and 130+ others).

Events

An event is a JSON object with top-level fields including source, detail-type, account, region, time, and a nested detail body:

{
  "source": "myapp.orders",
  "detail-type": "OrderPlaced",
  "detail": { "orderId": "abc", "amount": 49.99 }
}

Rules

A rule on a bus has either:

• An event pattern — a JSON matcher against incoming events (e.g., match all S3 ObjectCreated:Put events for a specific bucket).
• A schedule expression — cron or rate (legacy in EventBridge Rules; for new schedules use EventBridge Scheduler).

Matching events fan out to up to 5 targets per rule.

Targets (70+)

Popular targets include AWS Lambda, Amazon SQS, Amazon SNS, AWS Step Functions state machines, Amazon Kinesis Data Streams, Amazon Kinesis Data Firehose, Amazon ECS tasks, AWS Batch jobs, EventBridge Pipes, Systems Manager Run Command, another event bus (cross-bus / cross-account), and API destinations — signed HTTPS calls to any external API (Slack, PagerDuty, third-party webhooks). You can also apply input transformers to reshape the payload per target and dead-letter queues (DLQs) for unroutable events.

EventBridge Pipes

A newer feature, Pipes offers point-to-point integration with a standard pattern: source → (filter) → (enrichment) → target. Sources include SQS, Kinesis, DynamoDB Streams, Kafka (MSK), and self-managed Kafka/RabbitMQ. Optional enrichment calls Lambda, Step Functions, API destinations, or API Gateway. This replaces a lot of "Lambda consumer that calls another Lambda that writes somewhere" boilerplate.

Schemas

The Schema Registry stores OpenAPI / JSON Schema definitions of your events. Schema discovery can automatically infer schemas from traffic on a bus. IDEs and code generators produce typed bindings (Java POJOs, TypeScript types, Python classes) so producers and consumers stay in sync.

Archive and Replay

Enable an Archive on a bus to retain matching events (indefinitely or with a retention period). Replay pushes archived events back onto the bus, subject to a rule, between a start and end time. Essential for bug replays, regression testing, and recovery.

Key Features and Limits

• 130+ SaaS partner integrations via partner event sources.
• 70+ AWS service targets available out of the box.
• 5 targets per rule, 300 rules per event bus (soft).
• Content filtering — prefix, suffix, numeric range, anything-but, IP address matching on event fields.
• Cross-Region replication between buses.
• Cross-account delivery — one account's bus can target another account's bus.
• EventBridge Scheduler — separate service launched in 2022 for one-time and recurring schedules at scale (millions), replacing cron-style rules as the recommended path.
• Dead-letter queues on targets for failed deliveries.
• Retry policy with configurable maximum age and retry attempts.
• PutEvents API for custom event ingestion — batched up to 10 events / 256 KB per call.

Common Use Cases

1. Reacting to AWS service events — EC2 state change → Lambda, CodePipeline failure → SNS, S3 upload → Step Functions.
2. Loosely coupled microservices — domain events (OrderPlaced, PaymentCaptured) on a custom bus; each service subscribes to what it cares about.
3. SaaS-triggered automation — GitHub push → CodeBuild, Stripe webhook → Lambda, Zendesk ticket → Step Functions.
4. Cron at scale — EventBridge Scheduler replaces thousands of Lambda cron rules in large fleets.
5. Fan-out — one event triggers many downstream targets (Lambda + SNS + SQS) with per-target input transformers.
6. Point-to-point streaming with Pipes — DynamoDB Streams → enrichment Lambda → Kinesis.
7. Event replay / auditing — Archive provides compliance-grade retention and replay for bug investigation.

Pricing Model

• AWS-native events (from AWS services to the default bus) — free.
• Custom events — per million events published via PutEvents (roughly $1 / M).
• Partner events — per million events (partner tier pricing).
• Cross-account / cross-Region delivery — per million events.
• Archive storage — per GB-month.
• Replay — per million events replayed.
• Schema discovery — per event processed.
• EventBridge Pipes — per million events processed; enrichment charges separate.
• EventBridge Scheduler — per million scheduled invocations (cheaper than old Rules cron at scale).

Targets are billed separately (Lambda invocations, SQS messages, etc.).

Pros and Cons

Pros

• Fully managed, serverless — no brokers to operate.
• Native to AWS — tight IAM, CloudTrail, CloudWatch integration.
• Rich partner catalog for SaaS-triggered workflows.
• Content filtering cuts noise at the bus, not in Lambda.
• Archive / Replay is a killer feature for debugging and compliance.
• Pipes and Scheduler remove common boilerplate.

Cons

• ~0.5-second typical delivery latency — not a real-time streaming system.
• Max 256 KB per event; larger payloads need S3 pointers.
• 5-target-per-rule cap forces fan-out via SNS/SQS for wide distribution.
• Schema discovery can spam the registry if applications emit many versions.
• Troubleshooting silent filter mismatches requires careful CloudWatch Logs setup or the event pattern tester.

Comparison with Alternatives

| | EventBridge | Amazon SNS | Amazon SQS | Kinesis Data Streams | | --- | --- | --- | --- | --- | | Pattern | Event bus + rules | Pub/sub topic | Point-to-point queue | Ordered streaming log | | Filtering | Rich (content filtering) | Topic attributes | No | Consumer-side | | Fan-out | Yes (5 targets × rules) | Yes (many subscribers) | No | Multiple consumers | | Persistence | Archive (optional) | No | Up to 14 days | Up to 1 year | | Ordering | No | No (FIFO topic: yes) | FIFO queue: yes | Per-shard | | Replay | Yes (Archive + Replay) | No | No (redrive from DLQ only) | Yes | | Best for | Event-driven architectures, SaaS | High-throughput fan-out | Decoupling producers/consumers | Ordered streams, analytics |

EventBridge vs SNS: SNS is faster and cheaper for simple pub/sub fan-out, but EventBridge shines when you need content-based routing, partner sources, archive/replay, or 70+ native target types. Many teams use both: EventBridge for domain events, SNS for high-volume simple fan-out (mobile push, bulk notifications).

Exam Relevance

• Developer Associate (DVA-C02) — know EventBridge as the event bus, rules with event patterns, and the common targets (Lambda, SQS, SNS, Step Functions).
• Solutions Architect Associate (SAA-C03) — event-driven architectures, SNS vs SQS vs EventBridge trade-offs, cross-account event delivery.
• DevOps Professional (DOP-C02) — EventBridge for automation (CodePipeline failures → SNS, instance state changes → SSM Run Command), EventBridge Scheduler replacing Lambda cron fleets.
• SysOps Administrator (SOA-C02) — heavy coverage: scheduled rules, operational alerts, CloudWatch Events migration, troubleshooting filter patterns.

Exam trap: CloudWatch Events and EventBridge share the same underlying service and APIs — any CloudWatch Events feature is effectively EventBridge. Use EventBridge in new designs.

Frequently Asked Questions

Q: What's the difference between EventBridge and SNS?

A: Both fan out events, but they solve different problems. SNS is a high-throughput pub/sub topic: publishers send messages, subscribers (email, SMS, HTTP, SQS, Lambda) receive them. Filtering is limited to message attributes. EventBridge is an event bus with a rules engine: rich content-based filtering on the event body, 70+ native AWS target types, partner event sources, archive/replay, and schema registry. Rule of thumb: use SNS for simple, high-throughput fan-out where every subscriber wants every message; use EventBridge when you need content routing, SaaS events, multiple bus types, or built-in archiving.

Q: When should I use EventBridge Pipes instead of Rules?

A: Use Rules (the classic bus pattern) when you need one-to-many fan-out with content-based filtering. Use Pipes when you need point-to-point delivery with an optional enrichment step — typically a queue / stream → target pattern such as SQS → Lambda → DynamoDB or Kinesis → Step Functions. Pipes natively understand streaming sources (Kinesis, DynamoDB Streams, Kafka, RabbitMQ), handle polling and batching, and replace the boilerplate of writing a consumer Lambda. If your integration is strictly "one source feeding one target, with optional transform/enrichment," Pipes is usually simpler and cheaper.

Q: How does EventBridge Archive and Replay work?

A: You create an Archive on a specific event bus with a rule-style event pattern and retention period (days to indefinite). EventBridge transparently stores matching events. To replay, you specify the archive, a destination event bus, a replay event pattern (which rules to apply), and a start / end time. Events are pushed back onto the bus and routed according to current rules. Common uses: replay all yesterday's payment events after fixing a bug, regression-test a new consumer against historical traffic, or recover a downstream system that missed events during an outage. Replay respects current target configuration — so it's not a time-travel; it's "re-publish these events now."

---

This article reflects AWS features and pricing as of 2026. AWS services evolve rapidly — always verify against the official Amazon EventBridge documentation before making production decisions.