← Reddit Interview InsightsSoftware Engineer

Reddit·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
May 2026

Summary

System design round at Reddit for a software engineer role. The whole session was basically one big leaderboard question that kept branching into more and more sub-problems. Felt like a reasonable interview but there's a lot of ground to cover in one hour.

Questions Asked (1)

Q1

Design a real-time game leaderboard that supports score updates, top-K queries, rank lookups, range-based rank queries, and multiple leaderboard types (per game, per region, daily/weekly/all-time). It needs to handle tens of millions of players and potentially 100K+ score updates per second.

System DesignTechnical Trade-offsAlgorithms & Data Structures
Author's notes

This is the kind of question where you think you know where it's going and then they just keep pulling threads.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then propose a hybrid architecture using in-memory data structures (e.g., sorted sets) for real-time updates and a distributed store for persistence. Discuss partitioning strategies (e.g., by leaderboard key) and how to handle top-K, rank, and range queries efficiently, while addressing trade-offs like consistency vs. latency.

Pro tip: Emphasize that you would use Redis Sorted Sets for the core operations, as they provide O(log N) updates and O(log N + K) top-K queries, and mention that you'd shard by leaderboard key to scale horizontally. Also, discuss how to handle hot keys and ensure low-latency reads via caching.

1. Clarify Requirements and Scale

Ask questions to understand the exact query patterns, latency requirements, consistency needs, and expected read/write ratios. Confirm the scale: 10M+ players, 100K+ updates/sec, and multiple leaderboard dimensions.

2. High-Level Architecture

Propose a distributed system with a fast in-memory layer (e.g., Redis) for real-time operations and a persistent store (e.g., Cassandra) for durability. Use a message queue to ingest updates and asynchronously persist them.

3. Data Model and Partitioning

Design keys for each leaderboard type (e.g., game:region:timeframe) and partition data across nodes by these keys. Use consistent hashing to distribute load and replicate for fault tolerance.

4. Core Operations Implementation

For score updates, use atomic increments in sorted sets. For top-K, use ZREVRANGE. For rank lookup, use ZREVRANK. For range queries, use ZREVRANGEBYSCORE. Discuss how to handle ties and pagination.

5. Scalability and Trade-offs

Address hot keys by sharding within a leaderboard or using local aggregation. Discuss consistency (eventual vs. strong) and how to handle failures (e.g., Redis persistence, replication).

Key Points to Mention

  • Use of Redis Sorted Sets for O(log N) updates and efficient rank/top-K queries.
  • Partitioning by leaderboard key (game, region, timeframe) to scale horizontally.
  • Handling 100K+ updates/sec via sharded ingestion and asynchronous persistence.
  • Trade-offs between consistency and latency; eventual consistency for non-critical leaderboards.
  • Strategies for hot keys: sharding, local aggregation, or caching.
  • Data retention and aggregation for daily/weekly/all-time leaderboards (e.g., rollups).

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.