
SQS vs SNS: The Question That Finally Made Event-Driven AWS Click for Me
SQS and SNS both handle messaging in AWS, but they solve very different problems. This article explains the difference using a simple mental model and a real-world e-commerce example.
When I first started learning AWS, SQS and SNS confused me.
Both deal with messages.
Both are used to decouple applications.
Both can work with Lambda.
So naturally, I wondered:
Why does AWS need two different services for this?
After playing around with event-driven architectures, I realized that the answer is actually pretty simple:
SQS is about making sure work gets processed. SNS is about making sure a message gets distributed.
That distinction completely changed how I looked at AWS architectures.
The easiest mental model
Think about a restaurant.
SQS is the waiting line
Imagine 1,000 people suddenly enter a restaurant.
The kitchen can only prepare 20 orders at a time.
You don't want all 1,000 customers rushing into the kitchen.
Instead:
Customers ↓Queue ↓KitchenThe queue holds the work until the kitchen is ready.
That's essentially what Amazon SQS does.
A producer puts a message into the queue, and a consumer processes it when it is ready.
AWS describes SQS as a managed queue designed to decouple and scale distributed systems.
SNS is the announcement system
Now imagine the restaurant finishes an order.
Several people need to know about it:
Order completed ↓ ┌────┼────┐ ↓ ↓ ↓Email Inventory AnalyticsYou don't want the order-processing service to individually contact every system.
Instead, it publishes an event:
OrderCreatedto Amazon SNS.
SNS then distributes that message to its subscribers. SNS follows a publish/subscribe model and supports subscribers such as SQS queues, Lambda, HTTP endpoints, and others.
So:
SNS = "Everyone who cares about this event, here's the message."
Now let's put them together
This is where things started making sense to me.
Imagine an e-commerce application.
A customer places an order:
Customer ↓API Gateway ↓SQS ↓LambdaSQS protects the processing layer from sudden traffic spikes.
Lambda processes the order.
But after the order is created, several systems need to react:
Order Created ↓ SNS / | \ ↓ ↓ ↓InventoryEmailAnalyticsNow we are using both services for different reasons.
SQS:
"Don't lose this work. Process it when you're ready."
SNS:
"This event happened. Tell everyone who needs to know."
But here's where it gets even more interesting
You can actually combine SNS and SQS.
For example:
SNS / \ ↓ ↓ SQS Queue SQS Queue ↓ ↓ Lambda Lambda ↓ ↓ Inventory AnalyticsOne event is published to SNS.
SNS fans it out to multiple SQS queues.
Each system then processes its own queue independently.
AWS specifically supports subscribing SQS queues to SNS topics for this fan-out pattern.
This gives each consumer its own buffer.
And that's powerful.
What happens during a traffic spike?
Suppose your application normally receives:
100 orders/minuteEverything is fine.
Then Black Friday arrives:
50,000 orders/minuteWithout a queue, your processing system may suddenly have to deal with an enormous amount of work.
With SQS:
50,000 orders ↓ SQS ↓Lambda processes themat a manageable rateThe queue becomes a buffer between the producer and consumer.
This is one of the reasons I started seeing SQS differently.
It's not just:
"A service that stores messages."
It's a way of saying:
"These two parts of my application don't have to operate at exactly the same speed."
So when should you use each?
Here's the mental model I now use:
I need... | I think about... |
|---|---|
A buffer for work | SQS |
Asynchronous processing | SQS |
Protection from traffic spikes | SQS |
One message delivered to many subscribers | SNS |
Notifications | SNS |
Fan-out to multiple systems | SNS |
Fan-out + independent processing | SNS + SQS |
AWS's own decision guidance similarly frames SQS around queuing/decoupling and SNS around publish-subscribe messaging.
The biggest lesson I took away
Initially, I was trying to memorize:
"SQS does X and SNS does Y."
That wasn't helping much.
The better approach was to think about the problem I'm trying to solve.
Ask yourself:
"Do I need someone to process this piece of work?"
Think:
SQS.
"Do I need to tell several systems that something happened?"
Think:
SNS.
"Do I need both?"
Use:
SNS + SQS.
And suddenly the services stop feeling like random AWS products and start feeling like building blocks for solving architectural problems.
One last question
When you first started learning AWS, which two services confused you the most?
For me, SQS and SNS were definitely near the top of the list.
I'd be interested to hear what other people struggled with.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article