System Atlas
the atlas

SQS vs SNS vs EventBridge vs Kinesis

Four AWS messaging services, four different jobs — queue, fan-out, event bus, and stream.

the gist

AWS offers four messaging primitives that are easy to confuse. SQS is a durable queue for point-to-point work distribution with at-least-once delivery. SNS is pub/sub fan-out that pushes each message to many subscribers. EventBridge is an event bus that routes and filters events by content to many targets. Kinesis is an ordered, replayable stream for high-throughput real-time data. The right choice depends on delivery pattern, ordering, retention, and whether consumers need to replay history.

ANALOGY // SQS is a ticket spike orders wait on until a cook grabs one; SNS is a PA announcement heard by every department; EventBridge is a mailroom that reads each envelope and routes it by rules; Kinesis is a security-camera recording you can scrub back through anytime.
living diagram01 / 05
Retention · SQSup to 14 days
Delivery · SQSpoint-to-point queue
Retention · SNSnone — push now
Delivery · SNSpub/sub fan-out
Retention · EventBridgearchive + replay
Routing · EventBridgecontent filtering
Retention · Kinesis1–365 days, replay
Ordering · Kinesisordered shards
Four services compared on how long messages live and how they're delivered.
01

The shared job: decouple producers and consumers

All four services exist so a component that produces messages doesn't have to know or wait for the components that consume them. That decoupling absorbs spikes, isolates failures, and lets each side scale independently. The differences are in the delivery pattern, ordering guarantees, and how long messages stick around.

02

SQS — the queue

Simple Queue Service is a durable, point-to-point queue: producers enqueue messages and any number of worker instances pull and process them, deleting each on success. A message is handled by exactly one consumer, which makes SQS ideal for distributing a workload across a fleet. Standard queues are best-effort ordering and at-least-once; FIFO queues add strict ordering and exactly-once processing.

03

SNS — pub/sub fan-out

Simple Notification Service is a publish/subscribe hub: a single message published to a topic is pushed immediately to every subscriber — other queues, Lambda functions, HTTP endpoints, or email. It's fire-and-forget with no storage, so if no subscriber is listening the message is gone. SNS is the tool when one event must notify many independent systems at once.

04

EventBridge — the event bus

EventBridge is a serverless event bus built for routing. Producers emit structured events, and rules match on their content and shape to route each event to the right targets, with filtering, transformation, and a schema registry built in. It shines for event-driven architectures where many services react to many event types and you want routing logic centralized rather than hard-wired.

05

Kinesis — the stream

Kinesis Data Streams is an ordered, replayable log for high-throughput real-time data like clickstreams, metrics, and IoT telemetry. Records are partitioned into shards that preserve order, retained for up to a year, and read by multiple independent consumers that each track their own position. Because history is retained, a consumer can rewind and replay — impossible with a delete-on-read queue.

the full picture
01

Why AWS has four of these

The first time you see SQS, SNS, EventBridge, and Kinesis side by side, they look redundant — they all move messages between components. The confusion is understandable, but each was built around a different communication pattern, and picking the wrong one leads to awkward workarounds. The way to keep them straight is to stop asking "which moves messages?" (they all do) and ask four sharper questions: *Is delivery one-to-one or one-to-many? Does order matter? How long must messages live? Do consumers need to replay history?*

The shared motivation behind all of them is decoupling. Instead of Service A calling Service B directly — and failing when B is down or slow — A hands a message to a messaging service and moves on. That buffer absorbs traffic spikes, isolates failures so one slow consumer doesn't stall the producer, and lets each side scale on its own schedule. This is the foundation of event-driven and microservice architectures.

Given that shared purpose, the differences are entirely about pattern. SQS is a queue, SNS is a broadcast, EventBridge is a router, and Kinesis is a stream — and once you internalize those four shapes, the choice is usually obvious.

02

SQS: the work queue

Simple Queue Service is the classic message queue and the simplest of the four to reason about. Producers put messages onto a queue; a fleet of worker consumers pulls messages off, processes them, and deletes each one on success. The defining property is point-to-point: a given message is delivered to and processed by exactly one consumer. That makes SQS the natural fit for distributing a workload — image thumbnails to generate, emails to send, jobs to run — across however many workers you have, scaling the worker count up or down with the backlog.

SQS comes in two flavors. Standard queues offer nearly unlimited throughput with *at-least-once* delivery and *best-effort* ordering, meaning you might occasionally see a duplicate or an out-of-order message and must design consumers to be idempotent. FIFO queues guarantee strict ordering and exactly-once processing within a message group, at lower throughput.

Two mechanics matter in practice. A visibility timeout hides a message from other consumers while one worker processes it, so it isn't handled twice; if that worker crashes, the message reappears for another to retry. And a dead-letter queue captures messages that repeatedly fail, so a single poison message can't block the queue forever. Messages persist up to 14 days, giving consumers time to catch up.

03

SNS: pub/sub fan-out

Where SQS delivers each message to one consumer, Simple Notification Service delivers each message to *many*. It implements the publish/subscribe pattern: publishers send a message to a topic, and SNS immediately pushes a copy to every subscriber of that topic — which can be SQS queues, Lambda functions, HTTP/S endpoints, email, or SMS. One publish, many independent deliveries.

The key characteristics follow from that design. SNS is push-based and fire-and-forget: it does not store messages waiting to be pulled, so if a subscriber isn't reachable and has no buffering, the message can be lost (which is why durable subscribers are usually SQS queues). It is best-effort ordered by default. And it fans out with essentially no coupling — the publisher has no idea who is listening or how many, so you can add new reactions to an event without touching the producer.

A pattern you'll see constantly is SNS + SQS "fan-out": publish once to an SNS topic, and have several SQS queues subscribed, each feeding a different service's workers. This combines SNS's one-to-many broadcast with SQS's durable, independently-paced consumption — each downstream system gets its own reliable copy to process at its own speed.

04

EventBridge: the smart router

EventBridge looks like SNS at a glance — both send events to multiple targets — but its purpose is routing by content, not just broadcasting. It is a serverless event bus where producers emit structured JSON events, and you define rules that match on the event's fields and route matching events to the right targets, optionally transforming the payload along the way. Where SNS asks "who subscribed to this topic?", EventBridge asks "which of my rules does this specific event match?"

That content-based filtering is the whole point. A single bus can carry dozens of event types, and each consumer registers a rule describing exactly the events it cares about — say, only order.placed events over $500 from the EU region. The routing logic lives centrally in the bus rather than being hard-wired into producers, which is what makes it a clean backbone for event-driven architectures.

EventBridge also brings features aimed at integration: built-in connectors for many AWS services and dozens of SaaS partners as event sources, a schema registry that discovers and documents your event shapes, and archive and replay so you can re-drive past events through your rules. The trade-off versus SNS is higher latency and lower raw throughput — you pay a little for the routing intelligence.

05

Kinesis, and how to choose

Kinesis Data Streams is the odd one out: it is not a queue or a bus but a stream — a durable, ordered, replayable log, conceptually very close to Apache Kafka. Producers write records that are partitioned across shards by a partition key; each shard preserves strict order and provides a fixed throughput budget. The two properties that set it apart are long retention (1 to 365 days) and multiple independent consumers that each track their own read position. Because records aren't deleted on read, a consumer can rewind and replay — reprocess yesterday's data after fixing a bug, or add a brand-new consumer that reads the full history. That is impossible with delete-on-consumption SQS.

Kinesis targets high-throughput, real-time data: clickstreams, application and infrastructure metrics, log aggregation, and IoT telemetry — cases where order matters and many analytics jobs read the same firehose.

Putting it together as a decision guide:

  • Distribute work across a worker pool, one message each? → SQS.
  • Broadcast one event to many systems, right now? → SNS (often SNS→SQS fan-out).
  • Route many event types to many services by content, event-driven backbone? → EventBridge.
  • Ingest a high-volume ordered stream that multiple consumers read and replay? → Kinesis.

They also compose: it's common to fan out with SNS into SQS queues, or route with EventBridge into a Kinesis stream. Match the tool to the *shape* of the communication and the architecture almost designs itself.

what to remember
01

SQS: a durable queue for point-to-point work — one message is processed by one consumer, then deleted.

02

SNS: pub/sub fan-out — one published message is pushed to many subscribers at once, no storage.

03

EventBridge: an event bus that routes and filters events by content rules to many targets, with an event schema.

04

Kinesis: an ordered, high-throughput stream with long retention that many consumers can read and replay independently.

05

Ordering: SQS FIFO and Kinesis (per shard) preserve order; standard SQS and SNS are best-effort.

06

Retention: SNS keeps nothing after delivery; SQS holds up to 14 days; Kinesis holds 1–365 days for replay.

check yourself

Quick quiz

Q1

You need one event to immediately notify several independent systems at once, with no need to store it. Which fits best?

Q2

Which service lets a new consumer rewind and re-read events from hours ago?

follow the thread