Question 1

What is fan-out on write vs fan-out on read for news feeds?

Accepted Answer

Fan-out on write (push model): when User A posts, immediately write the post to the feed of all A's followers. Feed reads are O(1) — the feed is pre-built. Write amplification: one post → N writes where N = follower count. A user with 1M followers causes 1M Redis writes per post. Fan-out on read (pull model): when User B opens their feed, fetch recent posts from each of B's followees in real time and merge/rank them. No write amplification. Read is expensive: O(followees) DB queries per feed load, real-time merging. Hybrid (standard production approach): fan-out on write for users with < 10K followers; fan-out on read for celebrities (> 10K followers). On feed load, merge the pre-built feed (from write fan-out of normal followees) with a real-time fetch of celebrity posts. This eliminates write amplification spikes while keeping read latency low.

Question 2

How do you implement a feed with Redis sorted sets?

Accepted Answer

Store each user's feed as a Redis sorted set: key=feed:{user_id}, member=post_id, score=ranking_score. Insert: ZADD feed:{user_id} {score} {post_id}. Trim to keep only the top 500: ZREMRANGEBYRANK feed:{user_id} 0 -501 (removes everything below the top 500 by score). Read: ZREVRANGE feed:{user_id} 0 49 returns the top 50 post_ids by score in O(log n + k). Then batch-fetch post content from DB: SELECT * FROM posts WHERE post_id IN (...). At 500M users, memory for feed sorted sets: 500M * 500 posts * ~50 bytes = ~12.5TB. In practice, only store feeds for active users (accessed in last 30 days). Evict inactive feeds with Redis TTL or LRU policy.

Question 3

How do you rank posts in a content feed?

Accepted Answer

Feed ranking uses a scoring function combining multiple signals: (1) Recency — newer posts score higher; exponential decay: score *= exp(-lambda * hours_since_post). (2) Engagement velocity — likes + comments*2 + shares*3 per hour since posting. Viral posts with high engagement velocity score high even if slightly older. (3) Author relationship — posts from close friends (frequent interactions) score higher than casual follows. (4) Content affinity — match post type/topic to the user's historical engagement patterns (ML model). Score = w1*recency + w2*engagement + w3*relationship + w4*affinity. Weights are tuned via A/B testing. The score is computed at fan-out time and stored as the sorted set score. A periodic re-ranking job can recompute scores for posts in active feeds as engagement data accumulates.

Question 4

How does cursor-based pagination work for infinite scroll feeds?

Accepted Answer

Offset pagination (LIMIT 20 OFFSET 40) breaks for feeds: if 5 new posts are inserted, the 41st post at query time was the 36th post when the user started scrolling. Items appear twice or are skipped. Cursor pagination: the client sends the score (or timestamp) of the last seen item. The server fetches items with score strictly less than last_seen_score: ZREVRANGEBYSCORE feed:{user_id} {last_seen_score} -inf LIMIT 0 20. Since the cursor is a score value, not an offset, new inserts above the cursor don't affect pagination below it. The cursor is opaque to the client (encode as base64 if needed). For the first page: use +inf as the cursor. Store cursor in client state; server is stateless.

Question 5

How do you deliver new posts to feeds within 5 seconds?

Accepted Answer

Pipeline: post created → Kafka topic new_posts → fan-out worker pool. Workers consume from Kafka and execute ZADD for each follower. Latency is dominated by: Kafka produce latency (~5ms), Kafka consume latency (~10ms), fan-out time. For a user with 100K followers: 100K ZADD operations at ~0.5ms each = 50 seconds sequentially. Solution: parallel fan-out. Partition followers across N worker threads/goroutines. With 100 parallel workers: 1000 ZADDs each = ~0.5 seconds per worker = ~0.5s total. Kafka partitioning: partition by author_id so all posts from the same author go to the same partition (in-order per author). Workers are stateless and scale horizontally. At 100K posts/minute with 100K average followers: 100K * 100K = 10B ZADDs/minute — requires O(1000) Redis nodes and O(100) worker pods.

Content Feed System Low-Level Design

Requirements

Two Approaches: Fan-out on Write vs Fan-out on Read

Data Model

Feed Generation Service

Ranking Score

New Post Delivery (5s SLA)

Key Design Decisions