Pub-Sub vs Queuing

## The whole question is cardinality At its core, the distinction between publish-subscribe and point-to-point queuing is about **cardinality**: how many consumers receive a copy of any single message that enters the system. ## How a message moves in each model **Mechanism, step by step.** In a point-to-point queue, a producer places a message onto a named queue — a buffer managed by a broker (RabbitMQ, Amazon SQS, ActiveMQ, etc.). 1. Any number of consumer processes can attach to that same queue, but the broker guarantees that each message is handed to exactly one of them. 2. Internally the broker typically round-robins or load-balances messages across the connected consumers, removing the message from the queue once it is acknowledged. 3. This is the **competing-consumers** pattern: workers race for messages the way employees at a shared inbox race for tickets, and the queue's job is to make sure no two employees pick up the same ticket. **Pub-sub flips this.** A producer publishes a message to a topic (or exchange/subject), and the broker (Kafka, Google Pub/Sub, RabbitMQ fanout exchange, SNS) fans that message out to every subscription currently registered on the topic. Each subscription gets its own logical copy and its own delivery cursor, so subscriber A finishing quickly doesn't affect subscriber B lagging behind. ## Two problems in similar clothing Both exist because they solve two different problems wearing similar clothing. - **Queuing** solves "I have N units of work and M workers, and I want each unit done exactly once, load-balanced across the workers, so throughput scales as I add workers." It's the messaging equivalent of a thread pool's task queue. - **Pub-sub** solves an entirely different problem: "multiple independent parts of the system need to react to the same fact, and I don't want the producer to know or care who's listening." An order-placement event might need to be seen by inventory, billing, email, and analytics — four unrelated consumers, each needing every event, none of them competing for it. ## What each one buys you The trade-offs: | | Point-to-point queuing | Pub-sub | |---|---|---| | **Gives** | natural load-balancing and back-pressure — if consumers slow down, the queue simply grows, and you can add workers to catch up, with no risk of duplicate processing across workers (though a single consumer can still get a redelivery on crash) | loose coupling and easy extensibility — a new subscriber can start consuming tomorrow without the publisher's code changing at all | | **Costs** | its cost is that it's fundamentally single-purpose: once a message is consumed, it is normally gone, so a fifth interested party cannot be added after the fact without changing the producer or duplicating messages onto another queue | that flexibility costs you: you now have N independent consumption rates to manage, N sets of unacknowledged-message backlogs, and, in most systems, no automatic load-sharing per subscriber unless you layer consumer groups on top of subscriptions | ## What goes wrong In production, the failure modes split by pattern: - **A poison message on a plain point-to-point queue.** The classic failure is a poison message with no dead-letter handling — a message a worker can never successfully process gets redelivered indefinitely, blocking or slowing throughput as workers repeatedly pick it up, fail, and requeue it. - **A slow or dead subscriber**, the recurring pub-sub failure, causing unbounded backlog growth on its own subscription while every other subscriber is fine. Because subscriptions are independent, one broken consumer doesn't stop the others, but it can silently accumulate storage cost or eventually hit a retention-window cutoff and lose messages. - **Misuse of a queue as if it were pub-sub.** Teams also frequently do this, attaching many independent consumers to one queue expecting each to see everything, and are surprised when messages are actually split between them (competing-consumers, not fan-out), silently dropping most events per consumer. ## Composing both at different layers A concrete example: a checkout service publishes an `OrderPlaced` event onto a Kafka topic (pub-sub via consumer groups) so that the inventory service, the email service, and the fraud-analytics service can each independently and durably consume the full stream at their own pace, replaying from an offset if needed. Meanwhile, inside the inventory service itself, the actual decrement-stock work items are pushed onto an internal SQS queue (point-to-point) so a pool of ten inventory workers can load-balance the work, each SKU decrement handled exactly once by exactly one worker. The two patterns are frequently composed in the same architecture at different layers: **pub-sub for cross-service event distribution, queuing for intra-service work distribution**.