Problem Statement

Design a News Feed system that displays a personalized stream of posts from friends, pages, and groups. The system must handle billions of posts, serve hundreds of millions of daily active users, rank content by relevance, and deliver updates in near real-time.

Why This Problem Matters

• News Feed is Meta's flagship product and a canonical system design question that tests understanding of fan-out strategies, ranking systems, and caching at scale.
• Demonstrates ability to balance latency, consistency, and personalization in a read-heavy system.
• Reveals trade-offs between push (fan-out on write) and pull (fan-out on read) architectures.

Thought Process

Step-by-Step Reasoning

1. Post Creation: User creates a post → Write to Posts DB → Store media in blob storage → Trigger fan-out service.
2. Fan-out Service: For regular users, push post ID to followers' feed caches. For celebrities, mark as "pull-on-read" candidate.
3. Feed Generation: When user requests feed, fetch pre-computed feed from cache → Merge with pull-on-read candidates → Score with ranking model → Return top N posts.
4. Ranking: Fetch candidate features → Run through ML ranker → Apply diversity rules (avoid 5 posts from same friend) → Apply ads interleaving.
5. Real-time Updates: Use long-polling or WebSocket to push new post notifications → Client fetches updated feed.

Dry Run

Complexity Analysis

Annotated Solution

// Simplified Feed Service pseudocode
public class FeedService {
    private FeedCache feedCache;
    private PostStore postStore;
    private FollowGraph followGraph;
    private Ranker ranker;

    public List<Post> getFeed(String userId, int limit) {
        // 1. Get cached feed (pre-computed post IDs)
        List<String> cachedPostIds = feedCache.get(userId);

        // 2. Get pull-on-read candidates (celebrities user follows)
        List<String> celebrities = followGraph.getCelebrities(userId);
        List<String> pullPostIds = postStore.getRecentPosts(celebrities);

        // 3. Merge candidates
        Set<String> allCandidates = new HashSet<>();
        allCandidates.addAll(cachedPostIds);
        allCandidates.addAll(pullPostIds);

        // 4. Fetch full post objects
        List<Post> posts = postStore.batchGet(allCandidates);

        // 5. Rank and return top K
        return ranker.rank(posts, userId, limit);
    }

    public void publishPost(String authorId, Post post) {
        // Store post
        postStore.save(post);

        // Fan-out decision
        int followerCount = followGraph.getFollowerCount(authorId);
        if (followerCount < CELEBRITY_THRESHOLD) {
            // Push to followers' caches
            fanOutService.pushToFollowers(authorId, post.getId());
        }
        // Celebrities: post will be pulled on read
    }
}

Common Pitfalls

• Pure push model breaks down for celebrities—writing to millions of feed caches creates thundering herd problems and delays.
• Stale feeds: cached feeds can become outdated. Use TTL + background refresh to balance freshness vs load.
• Hot partitions: popular posts or users can overwhelm single nodes. Use consistent hashing with virtual nodes and replication.
• Privacy: deleted posts must be purged from all caches. Implement async deletion with eventual consistency.

Follow-Up Questions

• How would you implement "See less of this" functionality? (Store negative signals, adjust ranking model features)
• How do you handle feed for a new user with no friends? (Cold start with trending/suggested content)
• How would you A/B test a new ranking model? (Shadow scoring, percentage rollout, engagement metrics)

Key Takeaways