Subtracks & Tasks
At-Most-Once and At-Least-Once Delivery
Implement Basic Message Queue
Build a basic in-memory message queue: 1. Producers enqueue messages 2. Consumers dequeue messages 3. Messages delivered in FIFO order 4. Thread-safe...
Add Consumer Groups with Partitions
Implement Kafka-style consumer groups: 1. Topic has multiple partitions 2. Messages with same key go to same partition 3. Consumer group: each partit...
Implement At-Least-Once Delivery
Guarantee at-least-once delivery: 1. Consumer receives message (not removed from queue) 2. Message marked as "in-flight" with timestamp 3. Consumer p...
Implement Exactly-Once Semantics
Achieve exactly-once processing semantics: Producer side: 1. Assign unique ID to each message 2. Queue deduplicates by ID Consumer side: 1. Track pr...
Add Dead Letter Queues
Implement dead letter queues for failed messages: 1. Track retry count for each message 2. On processing failure, increment retry count 3. After N fa...
Exactly-Once Delivery
Understand Exactly-Once Delivery Challenges
**The exactly-once challenge**:. ```. Problem: Distributed systems make guarantees hard. Scenario 1: Producer retry. 1. Producer sends message to queu...
Implement Idempotent Consumers
**Idempotent consumers**:. ```. Problem: Messages may be delivered multiple times. Causes:. 1. Consumer crashes before ACK. 2. Network failures. 3. Qu...
Implement Transactional Message Processing
Transactional message processing ensures atomicity between message consumption and database updates, enabling exactly-once semantics through coordinat...
Implement Outbox Pattern
**The outbox pattern**:. ```. Problem: Publishing messages reliably. Scenario:. 1. Start database transaction. 2. Update business data (create order)....
Implement Two-Phase Commit for Queue and Database
Two-phase commit (2PC) coordinates atomic commits across multiple distributed systems, ensuring all participants commit or rollback together. **Probl...
Interview Prep
Common interview questions for Backend / Data Infrastructure Engineer roles that map directly to what you build in this track. Click any question to reveal the model answer.
Questions are representative of real interview patterns. Model answers are starting points — adapt them with your own experience and the specific context of the interview.
Common Mistakes
The top 5 mistakes builders make in this track — and exactly how to fix them. Click any mistake to see the root cause and the correct approach.
Comparison Mode
Side-by-side comparisons of the approaches, algorithms, and trade-offs you encounter in this track. Expand any comparison to see a detailed breakdown.
Concepts Covered
Prerequisites
It is recommended to complete the previous tracks before starting this one. Concepts build progressively throughout the curriculum.
Rabbit Holes
For when you want to go deeper. Curated papers, posts, and talks beyond what this track covers.
The Log: What every software engineer should know about real-time data's unifying abstraction
Jay Kreps' foundational essay on the append-only log as a unifying abstraction for messaging, databases, and stream processing. The essay that contextualized why Kafka was built the way it was.
Apache Kafka: A Distributed Streaming Platform (Paper)
Kreps, Narkhede, and Rao, 2011. The original Kafka paper presented at NetDB. Much shorter than the documentation; reading it tells you what the original design was optimizing for.
RabbitMQ vs Kafka: Two Different Problems
A concrete comparison of queue semantics (RabbitMQ's AMQP model) versus log semantics (Kafka's offset model). After building your own queue, the design differences will be much more legible.
Designing a Durable and Scalable Queue at Stripe
How Stripe migrated their job queue system without downtime. The operational challenges of migrating a live message queue are a useful counterpart to the clean design you implemented in this track.