System Shapes: Fan-Out (News Feed, Notifications, Chat)
In a fan-out system one write becomes thousands or millions of deliveries, and the design is a decision about when that multiplication happens and who pays for it. Here is the shape, the arithmetic, and a deep dive on news feeds, notifications, and chat.
A fan-out system is one where a single action has to reach many people. One post lands in the feeds of everyone who follows the author. One event produces a push notification, an email, and an SMS (Short Message Service) message for every subscriber. One chat message appears on every device of every member of the conversation. The write is cheap. The multiplication is the whole problem.
The first five minutes post says that naming the shape tells you where the difficulty lives. For fan-out, it lives in two places: delivering one thing to many recipients without the delivery work swamping everything else, and the hot users (celebrities, huge groups, mass announcements) whose follower count is four or five orders of magnitude above the median. This post walks through the shape, the arithmetic that drives it, and the three classic examples: news feed, notifications, and chat. Each looks like “send a thing to people,” and each makes a different decision about when the sending happens.
Where This Shows Up
Fan-out is the headline of several of the most common design prompts, and the hidden half of many others:
- “Design Twitter,” “Design the Instagram feed,” “Design the Facebook news feed.”
- “Design a notification service.” “Design a system that sends a push, email, and SMS when an order ships.”
- “Design WhatsApp,” “Design Slack,” “Design Messenger.”
- “A user with 50 million followers posts. Walk me through what happens.”
- “How does a user who has been offline for a week catch up?”
- “How do you make sure a notification is not sent twice?”
- “What changes if a group chat has 100,000 members instead of 10?”
- “Assume Twitter scale,” which, as the five-minutes post says, means the hard part is now delivery.
What They Are Really Checking
- Do you know where the work goes? Every fan-out design chooses between doing the multiplication at write time (push), at read time (pull), or some mix. The interviewer wants to hear the choice, the arithmetic behind it, and who pays.
- Do you handle the skew? The median user has a few hundred followers. The top user has tens of millions. A design that works for the median and melts on the celebrity is the most common failure in this question.
- Do you separate the index from the content? A feed or inbox should hold small references, not copies. Candidates who copy content into every recipient’s store have multiplied their storage and made every edit and delete a fan-out of its own.
- Can you state the delivery guarantees per recipient? Ordering, duplicates, missed messages while offline, and what the author sees. “It is eventually consistent” is not enough; name the anomaly the user would see.
- Do you isolate the big jobs? One 50-million-recipient fan-out must not delay a one-time password or a direct message. Priority and fairness are part of the design, not an optimization.
The Gotchas
Gotcha 1: Choosing push or pull without the follower distribution. Push is right for the median user and catastrophic for the celebrity; pull is the reverse. Ask for the distribution (or assume one) and let it pick a hybrid with a threshold.
Gotcha 2: Precomputing for people who will never read it. If 1 billion accounts follow and 200 million are active today, fanning out to every follower wastes most of the writes and most of the cache. Fan out only to recently active users and rebuild a feed on demand when a dormant user returns.
Gotcha 3: Copying content into every inbox. Store IDs (16 bytes) in the feed, not posts (1 kilobyte or more). Copies multiply storage by the follower count and make every edit and delete another fan-out.
Gotcha 4: Doing the fan-out on the request path. The author’s “post” call should return once the post is durably stored, not after 50 million inserts.
Gotcha 5: Forgetting the author. With asynchronous fan-out, the author posts, refreshes, and does not see the post. That is a read-your-writes violation. Merge the author’s own recent posts at read time.
Gotcha 6: Ordering chat by wall clock. Clocks disagree, so replies render above the message they answer. Assign a per-conversation sequence number at one owner.
Gotcha 7: One queue for all notifications. A marketing blast in front of a password-reset code is an outage to that user. Separate lanes by priority, with their own capacity.
Gotcha 8: Assuming exactly-once delivery. Queues are at-least-once and mobile clients resend, so duplicates are the default. Deduplicate with an idempotency key per (event, recipient, channel) and a client-generated message ID per chat message.
Gotcha 9: The notification that takes down your own read path. Send “live now” to 50 million phones in 60 seconds and a large fraction tap it at once. The stampede it causes is the incident. Spread delivery over minutes and warm the content first.
Gotcha 10: One strategy for every group size. A 1:1 chat and a 200,000-member channel are different systems. Small conversations fan out on write; large channels are read like a feed.
How to Answer
What defines the shape
| Property | Typical value | What it means for the design |
|---|---|---|
| Amplification | One write becomes 100 to 50,000,000 deliveries | Delivery work, not ingest, is the dominant load |
| Write to delivery ratio | Average 1:200 (median follower count), worst case 1:50,000,000 | Averages lie; capacity planning is driven by the tail |
| Access pattern | Each recipient reads “my stuff, newest first,” with a cursor | Per-recipient lists keyed by user ID, sorted by time or sequence |
| Skew | Follower counts are power-law distributed | Hot users need a different path, not a bigger machine |
| Recipient state | Most recipients are offline or inactive at any moment | Never assume delivery is immediate; design catch-up |
| Consistency tolerance | Feeds tolerate seconds of lag; chat requires strict per-conversation order; notifications require “at most once, effectively” | The tolerance differs per example, which is why they diverge |
So writes are rare and cheap, reads are frequent and simple, and the design effort goes into the delivery path between them: when the multiplication happens, how much of it you can skip, and how the outliers are handled.
The generic architecture
flowchart LR
A[Author / event source] --> W[Write API]
W --> S[(Source of truth<br/>posts, messages, events)]
W --> Q[[Fan-out queue]]
Q --> F[Fan-out workers]
F --> G[(Social graph /<br/>membership / subscriptions)]
F --> I[(Per-recipient index<br/>feed, inbox, sync log)]
F --> D[Delivery: push, WebSocket, email]
R[Recipient] --> RA[Read API]
RA --> I
RA --> H[Hydration: multi-get content]
H --> S
The source of truth holds each item once. Fan-out workers read the recipient list (social graph, membership, subscriptions), write a small reference into each recipient’s index, and optionally trigger a live delivery. Reads take a page of references and hydrate them with one multi-get.
The decision is when the arrow from the queue to the per-recipient index runs:
| Strategy | Work at write time | Work at read time | Good for | Bad for |
|---|---|---|---|---|
| Push (fan out on write) | One insert per follower | One read of a precomputed list | Normal users; read-heavy products; fast feed loads | Celebrities: one post becomes millions of writes |
| Pull (fan out on read) | One insert, into the author’s own list | Read every followee’s recent list and merge | Celebrities; users who rarely read | Users who follow 2,000 accounts: one feed load becomes 2,000 reads |
| Hybrid | Push for authors under a follower threshold | Pull and merge only the few hot authors the reader follows | Real social products | Adds a merge step and a threshold to maintain |
Now the arithmetic. Assume 200 million daily active users, each posting 0.5 times a day, with a median of 200 followers, and each opening the feed 10 times a day. Using the conversions from the back-of-envelope post (a day is about 100,000 seconds):
1
2
3
4
5
Posts: 100M/day -> ~1,000 posts/s average, ~3,000/s peak
Push inserts: 1,000 x 200 followers -> ~200,000 inserts/s, ~600,000/s peak
Feed reads: 2B/day -> ~20,000 reads/s, ~60,000/s peak
Feed storage: 500 entries x 16 bytes = 8 KB per active user
8 KB x 200M = 1.6 TB in memory (x2 or x3 with replicas)
At roughly 100,000 operations per second per Redis-class node, 600,000 inserts per second is a modest cluster. Push works for the median. Now the celebrity:
1
2
3
One post by an account with 50M followers -> 50,000,000 inserts
At 1,000,000 inserts/s for the whole cluster -> 50 seconds of all capacity
Ten such posts an hour -> the cluster does nothing else
That is the shape in two numbers: the average is fine, the tail is not, and the tail is what defines the design. The hybrid fixes it. Authors above a threshold (say 100,000 followers) are not pushed; their posts go only into their own recent-posts list, which is small, extremely hot, and cached everywhere. A reader who follows 15 such accounts pays 15 extra cache reads at feed-load time, which is cheap. A threshold is better stated as a cost comparison than a magic number: push when (followers x insert cost) is less than (active readers x merge cost), and recompute the classification daily.
The standard problems
| Problem | What goes wrong | Usual fix |
|---|---|---|
| Hot author | One post generates millions of writes and delays everyone else’s fan-out | Hybrid: pull for authors above a threshold, merged at read time |
| Inactive recipients | Most of the fan-out work and cache memory goes to people who never read it | Fan out only to users active in the last N days; rebuild on return |
| Content copies | Storage times follower count; edits and deletes need their own fan-out | Store IDs; hydrate on read; filter deleted or hidden items at hydration |
| Synchronous fan-out | Posting latency grows with follower count; timeouts at the tail | Durable write, then a queue; fan-out workers are asynchronous |
| Author does not see own post | Read-your-writes violation while the fan-out is in flight | Merge the author’s recent posts at read time, or write the author’s feed synchronously |
| Head-of-line blocking | A 50M-recipient job starves small, urgent ones | Split big jobs into chunks; separate queues by priority; fair scheduling per source |
| Duplicates and gaps | At-least-once queues double-deliver; offline clients miss pushes | Idempotency keys; per-recipient cursors; the index is the record, the push is a hint |
| Thundering herd after delivery | Millions of recipients act on the same item at once | Stagger delivery; pre-warm the item in cache; the read path must expect it |
Example 1: News feed (the canonical push-versus-pull trade)
Special property: the follow graph is wildly skewed and nobody needs every item. A feed is a ranked, lossy summary. Missing an item, showing it a few seconds late, or showing it in a slightly different order is invisible. That freedom is what makes the precompute-and-skip tricks legal.
The feed index holds candidates, not the feed. Modern feeds are ranked, so the precomputed list is a candidate set:
flowchart LR
C[Candidate generation<br/>feed index + hot-author pull] --> R[Ranking<br/>score ~500 candidates]
R --> H[Hydration<br/>multi-get posts, authors, counts]
H --> P[Policy filter<br/>deleted, blocked, privacy]
P --> U[Page of 20]
The feed index entry is a post ID plus an author ID or a timestamp, around 16 bytes. Keep the most recent 500 to 800 per user; older history is fetched by pulling, because nobody scrolls that far often enough to precompute it. Use time-sortable IDs (Snowflake-style: a timestamp in the high bits) so that sorting by ID is sorting by time without a coordinated clock.
Hydration is a read-heavy problem. Turning 20 IDs into a page means fetching 20 posts, their authors, and their like and comment counts. That is one batched multi-get per type, not 60 calls, and it is the read-heavy lookup shape in miniature: cached by ID, hot keys for viral posts, staleness tolerated on counts. Because content is hydrated, edits and deletes need no fan-out. A deleted post stays in 50 million feed indexes as a dangling ID and is filtered at hydration. Garbage collection can happen lazily.
Inactive users get nothing precomputed. The fan-out worker checks a “last active within 30 days” flag before writing. When a dormant user returns, their first feed load is a pull: read the recent lists of everyone they follow, merge, rank, and write the result into their index. Precomputing only for the active fifth of the user base cuts push work and cache memory by roughly five times.
Ordering is mostly a non-problem, with one exception. A ranked feed has no strict order to violate. The exception is causality across items: a reply or a share should not appear before the item it refers to, and a comment should not render on a post the viewer cannot see. Handle it at hydration: if the parent is missing or not visible to this viewer, hide the child. That is cheaper than causal ordering of the fan-out itself, and it is the anomaly described in the consistency post under causal consistency.
The author’s own view is a separate path. With asynchronous fan-out, a post takes seconds to reach followers, which is fine, and seconds to reach the author’s own feed, which is not. Merge the author’s own last few posts into their feed at read time. It is one extra cached read and it closes the read-your-writes gap without making the fan-out synchronous.
Example 2: Notifications (fan-out that leaves your system)
Special property: every delivery goes through a third party, costs something, and interrupts a human. A feed entry nobody reads costs 16 bytes. A notification costs money (SMS is priced per message), provider quota, and attention, and a duplicate or badly timed one is a reason to uninstall. So the design is less about throughput and more about deciding whether, when, and how to send each one.
flowchart LR
E[Domain events] --> N[Notification service]
N --> X[Expand recipients]
X --> P[Policy: preferences,<br/>quiet hours, frequency caps]
P --> DD[Dedup + aggregate]
DD --> T[Render template<br/>locale, channel]
T --> Q1[[Critical lane]]
T --> Q2[[Transactional lane]]
T --> Q3[[Bulk lane]]
Q1 & Q2 & Q3 --> S[Channel senders]
S --> APNS[APNs]
S --> FCM[FCM]
S --> EM[Email provider]
S --> SMS[SMS provider]
The channels are push through APNs (Apple Push Notification service) and FCM (Firebase Cloud Messaging), email, SMS, and the in-app inbox. Each has a different cost, latency, and failure model.
Preferences and policy are evaluated per recipient, per channel, at send time. The user may have turned off marketing email, kept security SMS, and muted one group. Evaluate at send time rather than at enqueue time, because a notification queued during a backlog should respect a preference changed in the meantime. The checks, in order:
| Check | Example | What it changes |
|---|---|---|
| Legal and hard opt-outs | Unsubscribed from marketing; SMS STOP received | Drop, never override |
| User preferences | “Comments: push only, no email” | Choose channels |
| Quiet hours in the recipient’s time zone | 22:00 to 07:00 local | Delay into a scheduled queue, do not drop; critical lane bypasses |
| Frequency caps | At most 3 social pushes per hour | Fold into a digest instead of sending |
| Recency of activity | User is in the app right now | Show in-app only; skip the push |
Deduplication needs an idempotency key, and the provider call is the weak spot. Use a key of (event ID, recipient ID, channel), recorded before the send, as described in the idempotency keys post. The remaining gap is a crash after the provider accepted the message but before your record says “sent.” That window produces a rare duplicate; accept it for push and email, and for SMS treat a stale “sending” record as “probably sent” rather than retrying blindly.
Aggregate before you send. “Alice liked your photo” followed by 37 more likes is 38 interruptions. Hold social notifications in a short aggregation window (a minute or two) keyed by (recipient, object, type), then send “Alice and 37 others liked your photo.” On the device side, APNs and FCM support collapse identifiers so a newer notification replaces the older one instead of stacking. Digests (“your daily summary”) are the same idea with a window of a day, and they are a scheduled job, which is the coordination shape.
Priority lanes are separate capacity, not a priority field. A single queue with a priority field still lets 50 million bulk messages fill the consumers’ buffers. Run separate queues and separate sender pools:
| Lane | Examples | Latency target | Behavior under pressure |
|---|---|---|---|
| Critical | One-time passwords, password reset, security alerts | Seconds | Reserved capacity; bypass quiet hours and caps |
| Transactional | Order shipped, message received, ride arriving | Under a minute | Scales first; may shed digests |
| Bulk | Marketing, “people you may know,” weekly digest | Minutes to hours | Throttled, paused, or dropped first |
Third-party limits and retries shape the senders. Providers throttle per account, per sender number, and per destination, and they fail transiently. The sender for each channel is a rate-limited client (a token bucket per provider, from the rate limiter post) with exponential backoff and jitter on transient errors, a dead-letter queue after a bounded number of attempts, and failover to a second provider for critical SMS. Provider feedback is data: APNs returns an “unregistered” status (HTTP 410) for a token whose app was removed, and FCM reports unregistered tokens too, so delete those tokens or you will keep paying to send into the void.
Mass fan-out needs pacing. A “live now” notification to 50 million followers at 100,000 sends per second takes about 8 minutes. That is acceptable for the notification, and it is also a feature: if it all landed in 30 seconds, a large fraction of 50 million people would open the app in the same minute. Chunk the recipient list (for example 10,000 recipients per task), spread the chunks over a few minutes, and pre-warm the target content in cache before the first chunk goes out.
Example 3: Chat (fan-out with strict order and live connections)
Special property: the conversation is the unit, every message matters, and order within it is strict. A feed may drop or reorder items; chat may not. Online recipients expect sub-second delivery, and offline ones expect every message on every device when they return.
The back-of-envelope post already sized this: 50 million daily users at 40 messages each is about 60,000 messages per second at peak and a wide-column store sharded by conversation. With 4 members per conversation, that is 180,000 device deliveries per second, more with multiple devices per user.
sequenceDiagram
participant A as Sender device
participant GA as Gateway (sender)
participant C as Chat service<br/>(conversation owner)
participant DB as Message store
participant GB as Gateway (recipient)
participant B as Recipient device
A->>GA: send(convId, clientMsgId, body)
GA->>C: forward
C->>C: dedupe clientMsgId, assign seq = 1042
C->>DB: append (convId, seq 1042)
C-->>A: ack: sent, seq 1042
C->>GB: deliver to online members' devices
GB->>B: message seq 1042
B-->>C: delivered (device cursor = 1042)
Per-conversation ordering comes from a single sequencer per conversation. Route every message for a conversation to one owner (the partition leader for that conversation ID), which assigns a monotonically increasing sequence number and appends it. No global order is needed and none is attempted; conversations are independent. Because one owner assigns the order, everyone in the conversation sees the same order, and a reply always has a higher sequence number than what its sender had already seen, which gives causal order within the conversation for free.
Storage is partitioned by conversation and clustered by sequence. The partition key is the conversation ID (with a time bucket for very long-lived conversations so partitions do not grow without bound); the clustering key is the sequence number. “Give me messages after 1042 in conversation X” is then one contiguous range read.
Sends are idempotent with a client-generated ID. Mobile networks drop acknowledgments, so clients resend. The client generates a message ID before the first attempt; the conversation owner deduplicates on (conversation ID, client message ID) and returns the original sequence number on a replay.
Offline delivery is a cursor, not a queue of pushes. The live push over a WebSocket is a hint for online devices. The truth is the log. Each device stores, per conversation, the last sequence number it has. On reconnect it sends its cursors, and the server returns everything after them (or “you are more than N behind, fetch the latest page and mark the rest as history”). This is why a missed push never loses a message. For a device that is offline, the chat service also hands a push notification to the notification system from Example 2, collapsed per conversation so ten messages do not produce ten alerts.
Receipts are cursors too. Sent means the server assigned a sequence number. Delivered means a device acknowledged it. Read means the user viewed it. Store one “delivered up to” and one “read up to” sequence number per member per conversation, not a flag per message per member. A group of 50 then has 100 small values to update, not 50 times the message count, and “read by 12” is computed by comparing cursors.
Group size changes the strategy.
| Conversation size | Fan-out strategy | Receipts | Notifications |
|---|---|---|---|
| 1:1 and small groups (up to a few hundred) | On write: deliver to every member’s devices; update each member’s conversation list | Per-member delivered and read | Push to every offline member |
| Large groups (hundreds to a few thousand) | On write to online members only; offline members pull on open | Read counts, not names, or none | Mentions and replies only by default |
| Channels and broadcast (tens of thousands and up) | On read: members fetch the channel log like a feed; push only to members currently viewing it | None | Opt-in, mentions only |
This is the news feed’s hybrid again, keyed on group size instead of follower count. A message to a 200,000-member channel pushed eagerly is the celebrity post with stricter ordering, and messaging products cap group sizes or switch to broadcast channels partly for this reason.
The connection layer is its own system. Holding millions of long-lived WebSocket connections, knowing which gateway each device is attached to, presence, and typing indicators are the real-time shape. For this design, it is enough to say: a fleet of gateways holds connections (on the order of 100,000 or more per box), a session registry maps device to gateway, the chat service looks up gateways for the recipients and forwards, and if a gateway is gone the message is still in the log and the device catches up by cursor.
Side by side
| News feed | Notifications | Chat | |
|---|---|---|---|
| Fan-out unit | Followers of an author | Subscribers of an event, times channels | Members’ devices in a conversation |
| Worst-case amplification | 50 million followers | 50 million recipients times channels | Large channel members |
| Strategy | Hybrid push and pull by follower count | Push, paced and policy-filtered | On write for small groups, on read for large |
| Ordering | Ranked; only causal parent-child matters | Rarely matters; collapse and replace | Strict per conversation, by sequence number |
| Loss tolerance | Missing an item is fine | Missing is bad; duplicates are worse | Neither loss nor duplicates allowed |
| Index holds | Post IDs, last ~500 | Notification IDs plus read cursor | Full message log plus per-device cursors |
| The twist | Celebrities, inactive users, hydration | Third parties, preferences, quiet hours, priority lanes | Sequencer per conversation, receipts as cursors, connections |
Where each example stops being fan-out
- News feed becomes read-heavy lookup at hydration: the posts, profiles, and counts behind the IDs are cached lookups. The engagement events that feed ranking (views, likes, dwell time) are write-heavy ingest, and they should never sit on the feed path.
- Notifications become coordination the moment there is time involved: quiet-hour delays, digests, and scheduled campaigns are a job scheduler with exactly-once claims. Delivery receipts and open tracking are, again, write-heavy ingest.
- Chat becomes real-time at the connection layer: presence, typing indicators, and holding millions of sockets. Very large channels drift back toward a feed. Nothing in the three examples is contended writes, which is itself a useful thing to say: there is no hot row, only a hot multiplication.
The sentence to say in the interview
This is a fan-out problem, so the hard part is not storing the post, it is delivering it to everyone who should see it without the celebrities and the huge groups swamping the system. I will push to the recent-activity indexes of active followers for normal authors, pull and merge for authors above a threshold, store IDs rather than content and hydrate on read, and merge the author’s own posts so they always see what they wrote.
The question that impresses, asked in the first five minutes: “What does the follower (or group size) distribution look like, and what fraction of recipients is active on a given day?” Those two numbers decide push versus pull and how much of the fan-out you get to skip.
Follow-Up Questions to Expect
- “Why not just fan out on read for everyone?” Following 2,000 accounts would mean 2,000 reads and a merge on every feed load, at 60,000 loads per second. Pull is right only where push is too expensive: hot authors and dormant readers.
- “How do you pick the celebrity threshold?” Compare costs: followers times insert cost against active readers times merge cost. In practice it lands in the tens to hundreds of thousands of followers, and it is recomputed periodically so an account that goes viral moves to the pull path.
- “A user deletes a post. What happens to 50 million feeds?” Nothing immediately. The feed holds IDs, hydration finds the post deleted and drops it, and the dangling IDs age out of the 500-entry window. That is the payoff for storing IDs.
- “How do you guarantee a notification is not sent twice?” You do not guarantee it at the provider; you make duplicates rare. An idempotency key per (event, recipient, channel) recorded before the send, collapse identifiers on the device, and an honest statement that a crash between the provider accepting the message and your record has a small duplicate window.
- “A user’s phone was off for a week. How does chat catch up?” The device sends its last sequence number per conversation and the server returns everything after it, latest page first for conversations far behind. Missed pushes do not matter; the log is the truth.
- “What about read receipts in a 10,000-member channel?” Turn them off or show a count. Per-member receipts in a large channel are a fan-out of their own, every time anyone reads.
Key Takeaways
- Fan-out means one write becomes many deliveries. The design is a decision about when the multiplication happens: write time, read time, or a hybrid.
- Do the arithmetic on the tail, not the average. 200 followers times 1,000 posts per second is easy; one post to 50 million followers is 50 seconds of a whole cluster.
- Hybrid is the standard answer: push for normal authors, pull and merge for hot ones, and nothing precomputed for inactive users.
- Store IDs, hydrate on read, and merge the author’s own recent posts so they always see what they wrote.
- Notifications are fan-out through third parties: per-recipient policy, deduplication keys, aggregation, separate priority lanes, provider rate limits, and paced mass sends.
- Chat is fan-out with strict order: one sequencer per conversation, storage partitioned by conversation, client-generated message IDs, and cursors for offline sync and receipts.
Further Reading
- Martin Kleppmann, Designing Data-Intensive Applications, chapter 1 (the Twitter home timeline as the worked example of fan-out on write versus read) and chapter 11 (stream processing)
- Adam Silberstein et al., “Feeding Frenzy: Selectively Materializing Users’ Event Feeds,” SIGMOD 2010 (the formal version of choosing push or pull per producer and consumer pair)
- Raffi Krikorian, “Timelines at Scale,” QCon San Francisco 2012 (how Twitter’s timeline fan-out actually worked)
- Nathan Bronson et al., “TAO: Facebook’s Distributed Data Store for the Social Graph,” USENIX ATC 2013 (the hydration side of a feed)
- Discord Engineering, How Discord Stores Billions of Messages (chat storage partitioned by channel and time bucket)
- Alex Xu, System Design Interview: An Insider’s Guide, volume 1, chapters on the news feed, notification system, and chat system
The Six Shapes
Each shape has its own deep dive. The shape tells you where the difficulty lives.
| Shape | Examples | Where the difficulty usually is |
|---|---|---|
| Read-heavy lookup | URL shortener, product catalog, profile service | Cache and read path; writes are trivial |
| Write-heavy ingest | Metrics, logging, clickstream | Ingest path, storage tiering, downsampling |
| Fan-out (you are here) | News feed, notifications, chat | Delivery to many recipients; hot users |
| Contended writes | Ticketing, inventory, auctions | Consistency on a hot row; the peak moment |
| Coordination | Scheduler, workflow engine, locks | Leases, exactly-once claims, failure recovery |
| Real-time | Ride matching, live location, collaborative editing | Latency, ordering, stateful connections |
Back to How to Run the First Five Minutes of a System Design Interview.