Engineering High-Throughput News Feed Architectures

2025-11-15•7 min read•Distributed Systems, Fan-out Strategy, Redis, Eventual Consistency, Feed Ranking, System Architecture

The Feed Problem: Scaling Beyond Simple Aggregation

At senior levels, designing a news feed moves past simple SQL joins. It becomes a challenge of write amplification management, handling massive social graphs, and balancing data freshness against computational cost. The objective is to deliver a personalized, ranked experience to millions of concurrent users with p99 latencies under 200ms.

1. Hybrid Fan-Out & Write Amplification

The core bottleneck of any feed is the "Fan-Out" process. We move beyond basic push/pull to a nuanced hybrid model:

  • Proactive Fan-out (Push): For "normal" users, we precompute the feed into a Redis-backed Timeline Cache. This optimizes for O(1) read performance.
  • On-Demand Aggregation (Pull): For "Celebrity" accounts (1M+ followers), pushing updates is computationally expensive and causes write spikes. Instead, celebrity posts are merged into a user's feed at read-time.
  • The Selective Fan-out Strategy: We use a metadata service to track user "activeness." If a follower hasn't logged in for 30 days, we stop pushing updates to their precomputed feed to save on expensive memory and I/O.

2. Multi-Stage Ranking Pipelines

Modern feeds require more than chronological sorting. We implement a tiered ranking architecture:

  • Candidate Generation: Quickly pull the latest ~1,000 posts from followed entities (high recall).
  • Scoring (ML Inference): A lightweight model scores candidates based on user affinity, content type, and engagement probability. This often runs as a sidecar to the feed service.
  • Re-ranking & Filtering: Apply business logic—deduplication, ad insertion, diversity heuristics (e.g., no more than two posts from the same user in a row), and safety/moderation filters.

3. Scaling the Data Layer

Standard sharding often fails when "Hot Keys" occur (e.g., a viral post).

  • Graph Storage: Use a specialized graph database or a highly optimized adjacency list in TAO (Facebook's style) or Cassandra to manage follower relationships.
  • Feed Persistence: Precomputed feeds should live in an in-memory store like Redis (using Sorted Sets). To handle memory constraints, we strictly limit the feed size (e.g., top 500 items) and overflow older data to a cold store.
  • Idempotent Processing: All fan-out workers must be idempotent. We use (post_id, user_id) as a composite key to prevent duplicate entries during retries in the event-driven pipeline.

4. Mitigating Bottlenecks & Availability

  • Thundering Herd Mitigation: When a celebrity posts, millions of "Pull" requests hit the system. We use Request Collapsing and aggressive caching of the celebrity's recent post object to protect the underlying DB.
  • Graceful Degradation: If the ranking engine latency exceeds a threshold, the system should fall back to a simple chronological feed rather than failing.
  • Write-Back Caching: For counters like "Like Counts" or "View Counts," we use Eventual Consistency. Update in-memory counters and flush to the persistent DB in batches using a buffer to avoid locking rows.

Conclusion

Senior news feed design is an exercise in asynchronous orchestration. By decoupling the write path (post creation) from the read path (feed serving) and implementing a hybrid, tiered ranking strategy, we build a system that is resilient to viral events and provides a sub-second personalized experience at a global scale.