System Design Fundamentals

11 items

Fundamentalsasyncmessage-queueskafkarabbitmqsqsfundamentalssystem-designintermediate

Asynchronous Processing & Message Queues

Decoupling systems with queues, events, and async patterns

Foundation knowledge|30 min read

Summary

Asynchronous processing decouples producers from consumers, enabling better scalability, resilience, and user experience. Instead of waiting for slow operations (email sending, image processing, analytics), acknowledge the request immediately and process later via message queues. Key concepts include delivery guarantees (at-least-once, at-most-once, exactly-once), back pressure handling, dead letter queues for failed messages, and idempotency for safe retries. Popular systems include RabbitMQ, Kafka, SQS, and Redis Streams.

Key Takeaways

Async Improves User Experience

Users don't need to wait for their email to send or their image to process. Acknowledge the request immediately, queue the work, and let background workers handle it. Perceived latency drops from seconds to milliseconds.

Message Queues Provide Temporal Decoupling

Producers and consumers don't need to be online simultaneously. The producer writes to the queue and moves on. The consumer processes when ready. This handles traffic spikes without overloading downstream systems.

At-Least-Once is the Safe Default

At-least-once delivery with idempotent consumers is the safest pattern. Messages may be delivered multiple times on failures, but idempotent processing ensures the same result regardless of retry count.

Synchronous: Caller waits for response. Simple but couples caller to callee.

Asynchronous: Caller sends request and continues. Response delivered later via callback, polling, or websocket.

When to use async: - Operation is slow (email, SMS, image processing) - Downstream system is unreliable - Result isn't needed immediately - Want to smooth traffic spikes

Sync vs Async Processing

Benefits of async: - Better user experience (fast response) - Resilience (retry failed operations) - Scalability (buffer traffic spikes) - Decoupling (services evolve independently)

Summary

Key Takeaways

Async Improves User Experience

Message Queues Provide Temporal Decoupling

At-Least-Once is the Safe Default

Dead Letter Queues Prevent Data Loss

When messages fail repeatedly, move them to a dead letter queue (DLQ) instead of discarding. This preserves failed messages for investigation and reprocessing while keeping the main queue healthy.

Back Pressure Prevents Cascading Failures

When consumers can't keep up, back pressure signals producers to slow down. Without it, queues grow unbounded, memory exhausts, and systems crash. Rate limiting and queue depth monitoring are essential.

Kafka is for Event Streams, RabbitMQ is for Task Queues

Kafka retains events for replay and supports multiple consumers reading the same data (event sourcing, analytics). RabbitMQ routes messages to workers and removes them after acknowledgment (work queues, RPC).

Deep Dive

Synchronous: Caller waits for response. Simple but couples caller to callee.

Asynchronous: Caller sends request and continues. Response delivered later via callback, polling, or websocket.

When to use async: - Operation is slow (email, SMS, image processing) - Downstream system is unreliable - Result isn't needed immediately - Want to smooth traffic spikes

Sync vs Async Processing

Benefits of async: - Better user experience (fast response) - Resilience (retry failed operations) - Scalability (buffer traffic spikes) - Decoupling (services evolve independently)

Trade-offs

Aspect	Advantage	Disadvantage
Sync vs Async Processing	Sync is simpler to reason about and debug; Async provides better UX, resilience, and scalability	Sync blocks on slow operations; Async adds complexity, requires idempotency and error handling
At-Least-Once vs Exactly-Once	At-least-once is simple and reliable; Exactly-once prevents duplicates	At-least-once requires idempotent consumers; Exactly-once is complex and expensive
Kafka vs RabbitMQ	Kafka: high throughput, replay, event sourcing; RabbitMQ: flexible routing, simpler for task queues	Kafka: more complex ops, no routing; RabbitMQ: no replay, lower throughput

System Design Fundamentals

Scalability Fundamentals

Latency, Throughput & Performance

Back-of-Envelope Calculations

Availability & Reliability Fundamentals

CAP Theorem & Consistency Models

Load Balancing Deep Dive