What happens when one click in your app needs to trigger five different actions at once, and three of them can’t fail? That is the moment most teams discover that picking the wrong messaging service on AWS is not a technicality. It is an architectural decision that decides whether your system stays calm under load or quietly drops work at 2 a.m.
SNS, SQS, and EventBridge all move information between parts of a system. They are often mentioned in the same breath. But they solve different problems, and mixing them up is one of the most common causes of messy, hard-to-debug workflows. This guide breaks down how each one actually behaves, where teams go wrong, and how the three fit together in a modern design.
What Each Service Actually Does
Before comparing, it helps to strip each service down to its core job.
SQS (Simple Queue Service) is a message queue. Producers put messages in. Consumers pull them out and process them. The queue holds the message until someone successfully handles it. This is a pull model, and it is the foundation of reliable background work. SQS comes in two flavors: standard queues (at-least-once delivery, best-effort ordering) and FIFO queues (exactly-once processing and strict ordering within a message group).
SNS (Simple Notification Service) is a publish/subscribe system. A publisher sends a message to a topic, and SNS pushes it out to every subscriber. Subscribers can be email addresses, webhooks, Lambda functions, or other queues. This is a push model, built for one-to-many delivery.
EventBridge is an event bus with content-based routing. Producers send events, and rules decide where they go by matching on the event’s content. It also connects to software-as-a-service and partner event sources, keeps a schema registry, and can archive events for later replay.
The short version: SQS stores work, SNS broadcasts messages, and EventBridge routes events based on what they contain.
The Push vs Pull Distinction That Changes Everything
The single most useful lens for telling these services apart is who initiates delivery.
With SQS, the consumer is in control. It asks the queue for messages when it is ready. That means a slow consumer does not get overwhelmed, because it sets its own pace. This is why SQS is the right home for background jobs, retries, and anything that must not be lost.
With SNS, the publisher is in control. It fires a message and SNS pushes it out. If a subscriber is not ready, that is the subscriber’s problem. SNS does not hold messages for later delivery. There is no replay. This makes SNS excellent for instant fan-out and a poor fit for durable work. (What is Amazon SNS? (AWS documentation))
EventBridge sits somewhere in between. It routes events and can archive them, but it is not a queue that a worker polls. It is a dispatcher that decides, based on rules, which targets should receive each event.
A practical rule of thumb: if you need a worker to grind through tasks at its own pace, you want SQS. If you need to announce something to many listeners right now, you want SNS. If you need smart routing based on event content, you want EventBridge.
Fan-Out: Where SNS and EventBridge Overlap
The classic fan-out pattern is an SNS topic feeding multiple SQS queues. One message arrives, SNS copies it to every subscribed queue, and each queue’s consumer processes it independently. If one consumer fails, the others are unaffected, and the failed queue can retry on its own schedule. (Publish–subscribe pattern (Wikipedia))
EventBridge can do something similar. A single rule can route an event to many targets. So which should you use for fan-out?
| Feature | SNS fan-out | EventBridge fan-out |
|---|---|---|
| Routing logic | Subscription filter policies on message attributes | Content-based pattern matching on the full event |
| Ordering | Standard topics are best-effort; FIFO topics support ordering | No ordering guarantee |
| Third-party sources | Limited | Native SaaS and partner event sources |
| Replay | Not supported | Archive and replay supported |
| Best for | Simple, high-volume broadcast | Complex, content-driven routing |
The honest answer is that most teams start with SNS fan-out because it is simple and cheap, then move to EventBridge when routing rules get complicated or when they need to consume events from outside AWS. If your filter logic is basically “which attribute equals what,” SNS subscription filter policies handle it fine. If your logic starts to look like a decision tree, EventBridge earns its place.
Delivery Guarantees and What They Really Mean
Delivery semantics are where quiet bugs are born. Here is how the three compare.
SQS standard queues deliver at least once. That means a message can show up more than once, so consumers must be idempotent, meaning processing the same message twice produces the same result. SQS FIFO queues offer exactly-once processing with deduplication inside a five-minute window, plus strict ordering within a message group.
SNS standard topics also deliver at least once, with best-effort ordering. SNS FIFO topics can deliver to SQS FIFO queues and support message grouping and deduplication.
EventBridge delivers at least once with best-effort ordering. It does not guarantee order, and it does not promise exactly-once handling.
The practical takeaway is blunt: assume duplicates everywhere except where you have explicitly chosen FIFO. A consumer that breaks when it sees the same order twice is a consumer that will eventually break in production. Building idempotency in from day one costs a little effort and saves a lot of pain.
Retention matters too. SQS keeps messages by default for four days, configurable up to fourteen. SNS does not retain messages for later delivery at all. EventBridge archives events with configurable retention, which is what makes replay possible.
Ordering: The Trap Most Teams Fall Into
Ordering feels like a detail until you ship an inventory system that subtracts stock out of sequence.
Only FIFO queues and FIFO topics guarantee order. Standard queues, standard topics, and EventBridge do not. That means if your workflow depends on step two always following step one, you have three real options:
- Use SQS FIFO queues with a message group ID that keeps related messages together.
- Route ordered work through a single consumer per group.
- Design the workflow so order does not matter, often by including sequence numbers or timestamps in the payload.
The third option is usually the most robust. Systems that tolerate out-of-order arrival are easier to scale and cheaper to run. But when order is genuinely required, FIFO is the tool, and it comes with throughput trade-offs worth understanding before you commit.
Filtering and Routing: Attribute Matching vs Content Matching
Filtering is where the services diverge most sharply in daily use.
SNS filters on message attributes. You define a filter policy, and SNS only delivers messages whose attributes match. It is fast, predictable, and works well when your routing key is a simple field like region or event type.
EventBridge filters on the event content itself. Rules match against the JSON structure of the event, so you can route on nested fields, combine conditions, and express much richer logic. It also supports scheduled rules using cron or rate expressions, and a separate scheduling service for one-off and recurring jobs.
A common mistake is trying to force complex routing into SNS filter policies. It works until it doesn’t, and then you end up with a tangle of topics that nobody wants to maintain. If your routing logic needs more than a couple of attribute comparisons, move it to EventBridge.
Where Teams Commonly Go Wrong
A few patterns show up again and again in real systems.
Using SNS as a queue. SNS does not retain messages. If a subscriber is down, the message is gone. Teams that expect retry behavior get silent data loss instead.
Skipping idempotency on standard queues. At-least-once delivery means duplicates. A consumer that charges a credit card twice because it did not check for a duplicate will eventually do exactly that.
Overusing FIFO. FIFO solves ordering but constrains throughput. Teams sometimes reach for it out of caution when their workflow could have tolerated out-of-order processing with a sequence number in the payload.
Ignoring the operational side. Messaging services are only as good as the tooling around them. If your team lives in a notes app for runbooks, it is worth comparing how Obsidian vs Logseq handle local-first notes by workflow so incident notes stay searchable when things go sideways. Small workflow choices compound.
Forgetting the human layer. Automated alerts are only useful if they reach someone. Teams that have tuned their desktop notifications know that disabling Copilot in Windows 11 without breaking your workflow is the kind of small cleanup that keeps on-call attention where it belongs.
How the Three Fit Together in a 2027 Design
The most durable pattern is not choosing one service. It is combining them deliberately.
A typical modern workflow looks like this:
- A producer sends an event to EventBridge because routing depends on event content.
- An EventBridge rule forwards matching events to an SNS topic for broadcast.
- SNS fans out to several SQS queues, one per downstream consumer.
- Each consumer polls its queue, processes work idempotently, and retries on failure.
- Failed messages land in a dead-letter queue for later inspection.
Each service does what it is best at. EventBridge handles smart routing. SNS handles broadcast. SQS handles durable, retryable work. Nothing is forced into a role it was not built for.
For teams building AI-assisted tooling around these workflows, the same principle applies: pick the tool that matches the job. A practical Claude writing workflow that actually works can help draft runbooks and incident summaries, but it will not replace a dead-letter queue. Similarly, when teams evaluate Claude alternatives in 2026 by workflow and price, the deciding factor is usually fit, not raw capability. Messaging services work the same way.
What to Watch Going Into 2027
The core behavior of these services has been stable for years, and that stability is a feature. But a few areas are worth tracking as designs evolve.
Event-driven architecture keeps growing, and EventBridge is where most of the new capability lands, particularly around SaaS integrations and schema management. Serverless adoption keeps pushing teams toward managed messaging over self-hosted brokers. And cost awareness keeps rising, since high-volume fan-out can get expensive fast if you fan out more than you need.
The safest approach is to design around the guarantees, not the feature list. Guarantees change slowly. Features change every quarter.
Conclusion
SNS, SQS, and EventBridge are not competitors. They are three tools with three different jobs. SQS stores work and lets consumers pull at their own pace. SNS broadcasts to many subscribers instantly. EventBridge routes events based on what they contain.
The teams that get this right do three things. They match the service to the delivery model they actually need. They assume duplicates and build idempotent consumers. And they combine the services rather than forcing one to do everything.
Get those three habits in place, and the workflow differences stop being a source of confusion. They become the reason your system stays predictable when traffic spikes and nothing gets lost along the way.
Frequently Asked Questions
Can I use SNS without SQS?
Yes. SNS can push directly to email, webhooks, Lambda functions, and mobile endpoints. But SNS does not retain messages, so if a subscriber is unavailable, the message is gone. For any work that must not be lost, pair SNS with SQS queues so each consumer gets durable storage and retries.
Is EventBridge a replacement for SNS?
Not really. EventBridge is better at content-based routing, third-party event sources, and replay. SNS is simpler and often cheaper for straightforward broadcast. Many architectures use both, with EventBridge routing events and SNS handling fan-out to queues.
When should I use a FIFO queue instead of a standard queue?
Use FIFO when order genuinely matters, such as financial transactions or state machines where step two must follow step one. FIFO provides exactly-once processing and strict ordering within a message group, but it comes with throughput limits. If your workflow can tolerate out-of-order delivery with sequence numbers in the payload, standard queues are usually simpler and cheaper.
Does EventBridge guarantee message ordering?
No. EventBridge delivers at least once with best-effort ordering. If your workflow depends on strict sequence, route ordered work through SQS FIFO queues instead, and use EventBridge only for routing decisions that do not depend on order.
How do I handle duplicate messages?
Build idempotent consumers. That means tracking a unique message or business key and skipping work that has already been done. Standard queues and standard topics both deliver at least once, so duplicates are expected, not exceptional. FIFO queues reduce duplicates within their deduplication window, but idempotency is still the safest default.
What is the difference between SNS filter policies and EventBridge rules?
SNS filter policies match on message attributes, which is fast and predictable but limited to simple comparisons. EventBridge rules match on the full event content, including nested fields, and support far richer logic. If your routing needs more than a couple of attribute checks, EventBridge is the better fit.
