Amazon Simple Queue Service was one of the earliest AWS services, launching publicly in the mid-2000s, well before "asynchronous, event-driven architecture" was a common phrase in mainstream engineering discourse. Its premise is almost aggressively simple: a durable, managed, fully hosted message queue that lets one part of a system hand off work to another part without either side needing to be available, fast, or even running at the same moment. That simplicity was deliberate, and it reflects a broader architectural philosophy Amazon had already been applying internally — favor asynchronous decoupling over synchronous, tightly coupled calls wherever a workflow can tolerate it.

Decoupling as a reliability strategy, not just a convenience

The core problem asynchronous queueing solves is temporal and failure coupling. In a synchronous call chain, if service B is slow or down, service A is stuck waiting on it, and that stall can cascade backward to whatever called A. Insert a queue between A and B instead, and A can hand off a message and move on regardless of B's current state; B processes the message whenever it's able to, and a temporary outage or slowdown in B turns into a growing queue backlog rather than a synchronous failure rippling through the whole call chain. That's the same category of problem Netflix's Hystrix addressed with circuit breakers, but SQS's queueing approach solves it structurally, by removing the synchronous dependency entirely, rather than by isolating and gracefully degrading a call that's still fundamentally synchronous.

At-least-once delivery and visibility timeouts

SQS's core mechanics reflect a deliberately pragmatic set of tradeoffs. Messages are delivered at least once rather than guaranteeing exactly-once by default, which means consumers need to be designed to handle occasional duplicate processing — usually by making message handling idempotent. When a consumer receives a message, SQS doesn't delete it immediately; instead it becomes invisible to other consumers for a configurable visibility timeout, and only gets permanently removed once the consumer explicitly acknowledges successful processing. If the consumer crashes or times out before acknowledging, the message becomes visible again and another consumer can pick it up — a straightforward mechanism that gives you retry-on-failure almost for free, without the queue needing to know anything about why the original attempt failed.

Dead-letter queues handle the case where a message keeps failing processing repeatedly: rather than retrying forever and clogging the main queue, a message that exceeds a configured retry count gets redirected to a separate queue for manual inspection or specialized handling, keeping poison messages from blocking the healthy flow of everything else.

A pattern that spread well beyond SQS itself

What makes SQS worth studying isn't really the service's specific API, it's the pattern it encoded early and made trivially easy to adopt: prefer asynchronous message passing over synchronous request-response wherever a workflow doesn't strictly require an immediate answer. That preference shows up repeatedly across Amazon's own internal architecture and across the broader industry's adoption of event-driven design — order processing pipelines, notification fan-out, background job processing, and inter-service workflows generally default to a queue or event bus rather than a direct synchronous call whenever the calling side doesn't need to block on the result.

What broke when they scaled

A queue that is "always writable" becomes a liability when consumers cannot keep up. Backlogs hide latency: the producer is fine, the SLO is not. SQS's early standard queues did not preserve strict ordering, which is correct for throughput and wrong for workflows that assumed FIFO (inventory adjustments, some payment steps). FIFO queues later added ordering and exactly-once processing within a message group — at the cost of throughput per group — because Amazon's own retail systems discovered that "just make it idempotent" is easy to say and hard when downstream systems are banks and warehouses.

Visibility timeouts are another scaling footgun. Too short, and a slow consumer duplicates work while the first attempt still runs. Too long, and a crashed consumer stalls a shard of the backlog until the timeout expires. At high parallelism you need heartbeats that extend visibility while work is healthy, plus a poison-message threshold that is not so high you burn compute forever on a bad payload.

Fan-out without architecture also hurts. SNS-to-SQS (and later EventBridge) exists because Amazon's service count made point-to-point queues a complete graph. Long polling and batch receive keep empty-receive costs down when the queue is quiet.

A smaller-team version of the same idea

Queue any step that need not answer the user in-request. Idempotent handlers, visibility timeout from p99, DLQ with an alarm. FIFO only for keys that require order.

What you can borrow

  • Default to asynchronous decoupling for any workflow step that doesn't need an immediate response — it removes an entire class of cascading-failure risk.
  • Design consumers to be idempotent; at-least-once delivery is usually the more resilient default even though it means occasional duplicate processing.
  • Use a visibility timeout (or equivalent) pattern to get automatic retry-on-crash without building custom retry bookkeeping.
  • Route persistently failing messages to a dead-letter queue instead of letting them retry forever and block healthy traffic behind them.