Design a News Feed: Mistakes That Cost Candidates the Round
By the BuildTheSystem team

"Design a news feed" is one of the most frequently asked questions in senior software engineering interviews. At first glance, the task sounds straightforward: fetch posts from the people a user follows, sort them by time, and return them to a mobile client. However, this question is designed to test how you handle asymmetrical traffic, graph expansion, and strict latency budgets.
Candidates often fail this round not because they lack system design knowledge, but because they jump straight to generic microservice diagrams without addressing the fundamental bottlenecks of feed generation. Similar to the patterns discussed in 7 System Design Interview Mistakes That Get Candidates Rejected, falling into predictable architectural traps signals a lack of hands-on production experience. Here are the major mistakes candidates make when designing a news feed, why interviewers mark them down, and how to structure your design to pass.
Choosing Fan-Out on Write Without Addressing the Celebrity Problem
The central architectural choice in any feed system is deciding when feed assembly happens: when a post is created (fan-out on write, or push model) or when a user opens the app (fan-out on read, or pull model).
A common failure mode is declaring that you will use fan-out on write for everything. In this approach, when an author posts, a background worker queries the social graph service for all followers and appends the new post ID into each follower's timeline cache, such as a Redis sorted set. Reading a feed becomes a fast O(1) cache lookup.
This design breaks down when applied to accounts with millions of followers. If an account with 30 million followers publishes a post, a single event triggers 30 million cache writes. At high write rates, message queues back up, write amplification spikes, and followers receive the update minutes or hours late. Interviewers call this the celebrity problem.
What to draw and say instead
Propose a hybrid fan-out model from the start:
- Regular accounts (under 50,000 followers): Use fan-out on write. When an ordinary user posts, push the post ID into their active followers' Redis caches.
- Celebrity accounts (over 50,000 followers): Use fan-out on read. Do not push their posts to follower caches. Instead, save the post once in the post store.
- Read path merge: When a user requests their feed, fetch their pre-computed timeline cache and merge it with recent posts pulled directly from the small set of celebrity accounts they follow.
Using Offset Pagination Instead of Cursor-Based Pagination
When designing the feed API, many candidates write standard REST endpoints using offset and limit parameters, such as GET /v1/feed?page=2&limit=20. This approach fails in high-throughput social networks.
Feeds are constantly receiving new items. If a user is viewing page 1 and three new posts are published, requesting page 2 with offset=20 shifts the window. The user sees the last three items from page 1 a second time. Conversely, if items are deleted, items are skipped entirely.
In addition, relational databases must scan through N offset rows before returning results, making higher page numbers progressively slower and heavier on disk IO.
What to draw and say instead
Use cursor-based pagination anchored to a post ID or timestamp. Define your endpoint like GET /v1/feed?cursor=post_102938&limit=20.
Explain that the cursor points to the last post received by the client. The backend queries for items created before that cursor value, ensuring stable windowing regardless of how many new posts enter the system between requests.
Storing Whole Post Data in Timeline Caches
Candidates frequently design feed caches that store full JSON objects inside each follower's feed list, including post text, author names, avatar URLs, and media links. This causes severe memory waste and cache invalidation issues.
If a user has 500 followers, copying a 2 KB post payload into 500 caches consumes 1 MB of Redis RAM for a single post. Furthermore, if the author edits their post title or updates their avatar, every pre-computed cache entry becomes stale, forcing expensive cache invalidation runs across millions of keys.
What to draw and say instead
Store only lightweight post IDs and timestamps in the timeline cache (for instance, inside Redis sorted sets scored by Snowflake IDs).
When a user opens their feed, the timeline service retrieves 20 post IDs from Redis, then makes a single multiget batch call to a dedicated post object cache (such as Memcached) to hydrate the full post contents. If an author edits a post, only one central object cache entry is updated.
Ignoring Feed Ranking and Treating the Timeline as Pure Chronology
Assuming a news feed is strictly chronological is a mistake in modern system design rounds. Facebook, Instagram, and Twitter all rely on algorithmic feed ranking based on user engagement signals.
Candidates who build pure time-sorted feeds fail to separate raw candidate retrieval from scoring. Conversely, candidates who try to compute deep machine learning scores for thousands of posts synchronously on every API call end up destroying their latency targets.
What to draw and say instead
Break your read path into a two-stage pipeline: candidate generation and candidate ranking.
- Candidate Retrieval: Pull the top 200 - 500 recent post IDs from the user's hybrid timeline cache.
- Feature Hydration & Scoring: Pass candidate post IDs through a lightweight ranking service that evaluates features such as affinity score, media type, post age decay, and historical interaction rates.
- Re-Ranking & Truncation: Sort the candidate set by final rank score and return the top 20 items to the client.
System Trade-Offs and Where the Hybrid Approach Breaks Down
Every architectural choice introduces new failure modes. An interviewer expects you to evaluate where your design experiences friction rather than claiming it is perfect.
| Strategy | Write Complexity | Read Complexity | Primary Failure Mode | Best Suited For |
|---|---|---|---|---|
| Fan-Out on Write | O(N followers) | O(1) cache lookup | Write storms on celebrity posts | Accounts with small followings |
| Fan-Out on Read | O(1) single write | O(F followees) read merge | Excessive database reads at scale | Platforms with low read-to-write ratios |
| Hybrid Approach | Moderate (conditional push) | Moderate (dual fetch & merge) | Pagination complexity across two streams | Large scale social networks |
The hybrid approach introduces three specific challenges:
- Read Path Complexity: Merging pre-computed sorted sets with live queries for celebrity posts forces the timeline service to execute multiple parallel fetches and manage merged pagination cursors.
- Cold Start and Inactive Users: Pushing posts to users who have not opened the app in months wastes memory. Systems must drop inactive users from fan-out queues and lazily rebuild their feeds when they return.
- Eventual Consistency Lag: Because fan-out workers process queues asynchronously via Kafka, a follower might refresh their feed immediately after a post and not see it for a few seconds.
How to Narrate Your Feed Design Out Loud in the Interview
How you talk through your design matters just as much as the components on your diagram. Silence or unguided drawing confuses interviewers and hides your reasoning.
When opening the round, state explicit scale assumptions early. For example, assume 100M daily active users, an average of 200 follows per user, and a 100:1 read-to-write ratio. Explain how these numbers make timeline reads the latency-critical path.
Narrate decisions before drawing them. Say: "Because reads dominate, I will pre-compute timelines using fan-out on write for regular users. However, to prevent Katy Perry's posts from overwhelming our message queues, I will bypass push workers for high-follower accounts and pull their posts at read time."
If you practice with AI mock interviews for system design, you can train yourself to state these trade-offs out loud while dragging components onto a interactive workspace. The AI interviewer listens while you think, waits while you draw, and asks targeted follow-up questions about the architecture you build. You can also experiment with component layouts using the free system design playground.
As outlined in our analysis of Design Dropbox: Mistakes That Cost Candidates the Round, clear verbal narration and intentional trade-offs turn a generic diagram into a passing senior engineer performance.
Frequently asked
What is the main difference between fan-out on write and fan-out on read?
Fan-out on write pushes post IDs into follower caches as soon as a post is created, making reads very fast but writes expensive. Fan-out on read stores the post once and gathers updates from followed accounts when a user opens their feed, making writes cheap but reads heavier.
How does a hybrid fan-out system solve the celebrity problem?
A hybrid system uses fan-out on write for ordinary accounts with modest follower counts, while skipping fan-out for accounts above a follower threshold (such as 50,000). Celebrity posts are queried at read time and merged into the user's pre-computed feed.
Why shouldn't I use page and offset for news feed pagination?
Offset pagination causes skipped or duplicated items when new posts are inserted while a user is scrolling. Cursor-based pagination uses a fixed post ID or timestamp anchor to deliver consistent page boundaries.
Rehearse this out loud, not just on paper
BuildTheSystem runs a live mock interview on a typed-component whiteboard — the interviewer listens, waits while you draw, and reacts the moment you connect something questionable.
Start a mock interviewRead next
Design Dropbox: Mistakes That Cost Candidates the Round
Learn why uploading whole files, omitting block chunking, and treating sync like basic REST endpoints fail system design interviews, and how to fix your architecture.
7 System Design Interview Mistakes That Get Candidates Rejected
The recurring mistakes that sink otherwise-solid system design interview performances, from skipping requirements to silent whiteboarding.
Database Replication in System Design: When to Use It
A practical guide for system design interviews on when database replication scales your system, when it adds operational cost without benefit, and how to narrate your choice out loud.