Design a Real-Time Gaming Leaderboard

1. Problem Statement & Scope Clarification

System Mission

Design an ultra-low-latency, real-time gaming leaderboard service (similar to Xbox Live, PlayStation Network, and competitive esports platforms) capable of processing hundreds of thousands of score updates per second, maintaining exact global rankings across tens of millions of players, and delivering Top-$N$ and surrounding rank windows in under 5 milliseconds.

Functional Requirements

1. Score Submission (SubmitScore): Ingest and atomically update a player's score for a specific game and season, recalculating their global rank in real time.
2. Top-$N$ Global Leaderboard (GetTopRankings): Retrieve the current top $N$ players (e.g., Top 100) with ranks, usernames, avatars, and verified scores.
3. Surrounding Player Window (GetSurroundingRanks): Retrieve a specific player's exact rank along with $M$ players directly above and below them (relative ranking window).
4. Deterministic Tie-Breaking: Automatically break score ties by awarding the higher rank to the player who achieved the score earlier in time.
5. Periodic & Seasonal Reset: Support daily, weekly, and seasonal leaderboard archival and zero-downtime rollover.

Non-Functional Requirements (SLAs & SLOs)

• Availability: $99.999\%$ uptime SLA.
• Latency:
  • Read Latency (Top-$N$ and Relative Window): $P99 < 5\text{ ms}$.
  • Write Latency (Score Ingest & Rank Calculation): $P99 < 15\text{ ms}$.
• Throughput: Support $> 100,000\text{ score submissions/sec}$ during global live gaming events.
• Accuracy: $100\%$ linearizable rank precision for top-tier competitive play (no stale or skipped ranks).

2. Capacity & Scale Estimation (Back-of-the-Envelope Math)

Player Base & Ingest QPS

• Total Registered Players: $50,000,000$ ($50\text{M players}$).
• Daily Active Players (DAU): $10,000,000$ ($10\text{M DAU}$).
• Average Ingest QPS: $\text{Average Ingest QPS} = \frac{10\times 10^6 \times 50\text{ matches/day}}{86,400\text{ sec}} \approx \mathbf{5,787\text{ updates/sec}}$
• Peak Ingest QPS ($18\times$ spike factor during esports tournaments): $\text{Peak Ingest QPS} = \mathbf{100,000\text{ updates/sec}}$
• Read QPS (Top-$N$ views from game menus): $\text{Peak Read QPS} = \mathbf{50,000\text{ reads/sec}}$

Memory Footprint Derivation (Redis Sorted Set)

A Redis ZSET uses a dual-structure: a SkipList (for $O(\log N)$ range scans) and a Hash Table (for $O(1)$ score lookups):

• Member ID (usr_998124): $\approx 16\text{ bytes}$
• Score (float64 IEEE-754 double precision): $\approx 8\text{ bytes}$
• SkipList Node pointers (forward/backward pointers, level spans): $\approx 32\text{ bytes}$
• Hash Table dictionary entry: $\approx 24\text{ bytes}$
• Jemalloc memory alignment overhead: $\approx 16\text{ bytes}$
• Total per Player Record: $\approx 96\text{ bytes}$.

$\text{Active Leaderboard Memory} = 50,000,000\text{ players} \times 96\text{ bytes} \approx \mathbf{4.8\text{ GB RAM}}$ With 3x Redis replication and multiple game modes (10 game modes $\times 4.8\text{ GB} = 48\text{ GB}$), a cluster of 3 cache.r6g.xlarge nodes (26.32 GiB RAM each) easily holds the entire state in memory.

3. High-Level Architecture & AWS Component Mapping

Interactive Architecture Diagram
100%Fit100%
Synthesizing vector architecture diagram...

4. API Interface Design & Tie-Breaking Score Math

1. Deterministic Microsecond Tie-Breaking Formula

If Player A and Player B both achieve a score of $50,000$, standard Redis ZSET orders members lexicographically by their user_id. To guarantee that the player who scored first gets the higher rank, we encode epoch milliseconds into the fractional decimal bits:

$\text{Combined Score} = S_{\text{raw}} + \left( 1.0 - \frac{T_{\text{now\_ms}}}{10^{13}} \right)$

Where $T_{\text{now\_ms}}$ is the millisecond timestamp when the score was achieved. Since $T_{\text{now\_ms}}$ grows monotonically, an earlier timestamp yields a slightly larger fractional value, guaranteeing deterministic first-achiever precedence:

textCopy
Score A (at t=1000): 50000 + (1 - 0.000000001000) = 50000.999999999000
Score B (at t=2000): 50000 + (1 - 0.000000002000) = 50000.999999998000
-> Score A > Score B (Player A is ranked higher)

2. gRPC Interface Specification (leaderboard.proto)

protobufCopy
syntax = "proto3";

package hispeeddesign.leaderboard.v1;

service LeaderboardService {
  rpc SubmitScore (SubmitScoreRequest) returns (SubmitScoreResponse);
  rpc GetTopRankings (GetTopRankingsRequest) returns (GetTopRankingsResponse);
  rpc GetSurroundingRanks (GetSurroundingRanksRequest) returns (GetSurroundingRanksResponse);
}

message SubmitScoreRequest {
  string game_id = 1;
  string season_id = 2;
  string user_id = 3;
  double raw_score = 4;
  string match_verification_token = 5;
}

message SubmitScoreResponse {
  int64 global_rank = 1;
  double verified_score = 2;
  bool is_new_high_score = 3;
}

message GetTopRankingsRequest {
  string game_id = 1;
  string season_id = 2;
  int32 top_n = 3;             // Default: 100
}

message LeaderboardEntry {
  int64 rank = 1;
  string user_id = 2;
  string username = 3;
  string avatar_url = 4;
  double score = 5;
}

message GetTopRankingsResponse {
  repeated LeaderboardEntry entries = 1;
  int64 total_participants = 2;
  int64 last_updated_epoch_ms = 3;
}

message GetSurroundingRanksRequest {
  string game_id = 1;
  string season_id = 2;
  string user_id = 3;
  int32 radius = 4;            // e.g. 5 (fetches 5 above and 5 below)
}

message GetSurroundingRanksResponse {
  int64 user_rank = 1;
  repeated LeaderboardEntry surrounding_entries = 2;
}