Design a Public High-Scores Leaderboard

System Design
Medium
Google
58.3K views

Design a system for a video game to maintain a global, real-time leaderboard. Discuss data structures (Redis Sorted Sets) and handling fraudulent scores.

Why Interviewers Ask This

Interviewers ask this to evaluate your ability to design scalable, real-time systems under high concurrency. They specifically test your knowledge of data structures like Redis Sorted Sets for O(log N) operations and your awareness of security risks in gaming ecosystems, such as score manipulation or bot attacks.

How to Answer This Question

1. Clarify requirements: Define scale (users per second), latency needs (real-time vs. eventual consistency), and specific constraints like fraud detection thresholds. 2. High-level architecture: Propose a microservices approach where game servers write scores to an API gateway before hitting the caching layer. 3. Data modeling: Explain why Redis Sorted Sets are ideal here, detailing how they store scores with O(log N) insertion and range queries for top-N retrieval. 4. Fraud prevention: Discuss implementing rate limiting, anomaly detection algorithms (e.g., flagging impossible speed records), and human review queues. 5. Scalability and failure: Address sharding strategies for massive datasets and fallback mechanisms if Redis fails.

Key Points to Cover

  • Explicitly choosing Redis Sorted Sets for their O(log N) complexity and native ordering capabilities
  • Demonstrating a concrete strategy for detecting and preventing score manipulation or botting
  • Addressing consistency models and how to handle potential race conditions during simultaneous updates
  • Proposing a sharding or partitioning strategy to ensure horizontal scalability
  • Considering fallback mechanisms and error handling for distributed system failures

Sample Answer

To design a global, real-time leaderboard, I would start by clarifying that we need sub-second latency for updates and strict integrity against bots. For the core data structure, Redis Sorted Sets are the industry standard because they automatically maintain order and allow O(log N) insertion and O(1) retrieval of the top K players, which is critical for high-frequency gaming sessions. The system flow would involve the game client sending a signed request to an API Gateway, which validates the user session and checks for basic rate limits. Validated scores are then written to Redis with the player ID as the member and the score as the score value. To handle fraud, we must implement a multi-layer defense. First, server-side logic should verify that the score is physically possible based on game mechanics and historical averages. Second, we can use a sliding window counter to detect rapid-fire submissions indicative of automation. Finally, any score exceeding a certain percentile threshold could be flagged for manual review or temporary suspension until verified. If traffic spikes beyond a single Redis instance's capacity, we would shard the data by region or game mode. This approach ensures low latency while maintaining data integrity, aligning with Google's emphasis on robust, scalable infrastructure.

Common Mistakes to Avoid

  • Ignoring the security aspect entirely and focusing only on the data structure without discussing fraud detection
  • Suggesting a relational database like MySQL for the primary storage, which would struggle with the required write throughput and sorting performance
  • Failing to define the read/write patterns clearly, leading to an inefficient design that doesn't match real-world gaming traffic
  • Overlooking edge cases like tie-breaking rules or what happens when a player submits multiple scores in quick succession

Practice This Question with AI

Answer this question orally or via text and get instant AI-powered feedback on your response quality, structure, and delivery.

Start Practicing

Related Interview Questions

Browse all 150 System Design questionsBrowse all 87 Google questions