Design Facebook News Feed

#Problem Statement

Design a news feed system where users can publish posts and see a personalized, ranked feed of posts from people they follow. Think Facebook, Instagram, Twitter timeline.

📖

Real-world: The feed is the home of the "fan-out on write vs fan-out on read" tradeoff, and the canonical war story is Twitter's celebrity problem: precomputing each user's timeline on write (push) is great for normal users but explodes for accounts with tens of millions of followers — when Lady Gaga tweets, you can't synchronously write to 80M inboxes. Twitter's real architecture became a hybrid: push for most users, but pull (compute at read time) for celebrity posts, merged in when you load your feed. The early Twitter that couldn't handle this gave us the legendary "fail whale." Security/integrity angle for this audience: the modern feed is also a ranking and trust-and-safety battleground — spam, coordinated inauthentic behavior, and misinformation are filtered in the same pipeline that ranks for engagement, so "the feed" is as much an abuse-detection system as a distributed-systems one.

#Requirements

#Functional

• Users can create posts (text, images, links)
• User sees a ranked feed of posts from people/pages they follow
• Feed is paginated
• Feed is somewhat real-time (new posts appear within minutes)

#Non-Functional

• 500M daily active users
• Average user follows 300 others
• Peak: 5M posts/s (like spikes during events)
• Feed read latency: < 200ms P99
• Eventual consistency is acceptable (slight staleness is OK)

#Scale Estimation

• Write: 500M users × 10 posts/day / 86400 = 58k posts/s average
• Read: 500M users × 10 feed loads/day / 86400 = 58k feed reads/s average
• Fan-out: each post written → pushed to followers' feeds. Average 300 followers = 17M feed writes/s (!)
• Celebrity problem: Justin Bieber with 100M followers = 100M feed writes per post (!)

#Core Design

The fundamental choice: fan-out on write vs fan-out on read.

#Fan-Out on Write (Push Model)

User posts → Post Service → Fan-out Worker Queue
                                     ↓
                        For each follower: write post_id to their feed cache
                                     ↓
                               Feed Cache (Redis)
                                     ↑
                          User loads feed → read from cache

#Fan-Out on Read (Pull Model)

User loads feed → Feed Service → fetch following list
                                      ↓
                          Query N "post" tables for each followee
                                      ↓
                              Merge + rank → return

#Hybrid Model (Production Reality)

Regular users (< 1000 followers):  fan-out on write → pre-populated feed cache
Celebrity users (> 1M followers):  fan-out on read → fetched and merged at read time

At feed load time:

1. Read pre-computed feed IDs from Redis (regular followees)
2. Fetch last N posts from celebrity followees directly
3. Merge + rank all posts
4. Return paginated result

#Architecture

                    Post Service (write)
                         |
              ┌──────────┴──────────────┐
              │                         │
        Fan-out Queue              Post DB (Cassandra/DynamoDB)
              │                         │
         Fan-out Workers           Object Store (S3 for media)
              │
        Feed Cache (Redis)
        {user_id: [post_id, post_id, ...]}

                    Feed Service (read)
                         |
                 Check Redis Cache
                 + Merge celebrity posts
                 + Hydrate post data (Post Service)
                 + Ranking (ML model)
                 → Response

#Data Models

Posts DB (Cassandra — wide-column, excellent for time-series queries):

posts_by_author(
  author_id  UUID,
  created_at TIMESTAMP,
  post_id    UUID,
  content    TEXT,
  media_urls LIST<TEXT>,
  like_count INT,
  ...
  PRIMARY KEY (author_id, created_at DESC)
)

Feed Cache (Redis):

Key:   feed:{user_id}
Value: sorted set of post_ids ordered by rank_score
TTL:   24 hours (rebuild on miss)

#Ranking

Simple scoring: score = base_time_decay + engagement_boost + affinity_score

• Can be a lightweight ML model or simple formula
• Applied during fan-out write OR at read time (trade latency for freshness)

#Key Design Decisions

#Security Considerations

#Interview Tips