QPS Estimation Explained — How to Calculate Queries Per Second Like a Pro

# QPS Estimator — Back-of-Napkin System Design Calculator
# Run this with Python 3. No external libraries needed.

def estimate_qps(
    daily_active_users: int,
    reads_per_user_per_day: int,
    writes_per_user_per_day: int,
    peak_multiplier: float = 3.0
) -> dict:
    """
    Converts user-level product metrics into engineering-level QPS numbers.
    peak_multiplier: how much higher than average your busiest hour gets.
                     Use 2x for stable enterprise apps, 5x for viral consumer apps.
    """
    SECONDS_IN_A_DAY = 86_400  # 60 seconds * 60 minutes * 24 hours

    total_daily_reads  = daily_active_users * reads_per_user_per_day
    total_daily_writes = daily_active_users * writes_per_user_per_day
    total_daily_requests = total_daily_reads + total_daily_writes

    # Average QPS — assumes traffic is perfectly flat across 24 hours (it never is)
    avg_read_qps  = total_daily_reads  / SECONDS_IN_A_DAY
    avg_write_qps = total_daily_writes / SECONDS_IN_A_DAY
    avg_total_qps = total_daily_requests / SECONDS_IN_A_DAY

    # Peak QPS — the number your system MUST handle without degrading
    peak_read_qps  = avg_read_qps  * peak_multiplier
    peak_write_qps = avg_write_qps * peak_multiplier
    peak_total_qps = avg_total_qps * peak_multiplier

    # Read/write ratio — critical for choosing DB architecture (replicas, caching strategy)
    read_write_ratio = total_daily_reads / max(total_daily_writes, 1)  # guard against division by zero

    return {
        "avg_read_qps":    round(avg_read_qps,  1),
        "avg_write_qps":   round(avg_write_qps,  1),
        "avg_total_qps":   round(avg_total_qps,  1),
        "peak_read_qps":   round(peak_read_qps,  1),
        "peak_write_qps":  round(peak_write_qps, 1),
        "peak_total_qps":  round(peak_total_qps, 1),
        "read_write_ratio": round(read_write_ratio, 1),
    }


# --- Example: Twitter-like social feed app ---
# Assumptions:
#   50 million DAU (mid-size social network)
#   Each user reads 30 tweets per session (timeline, explore, notifications)
#   Each user writes 1 tweet + 5 likes = 6 write actions per day
#   Peak multiplier of 3x (busy evenings vs. quiet early mornings)

results = estimate_qps(
    daily_active_users=50_000_000,
    reads_per_user_per_day=30,
    writes_per_user_per_day=6,
    peak_multiplier=3.0
)

print("=== QPS Estimation: Twitter-like App ===")
print(f"  Average Read  QPS : {results['avg_read_qps']:>10,.1f}")
print(f"  Average Write QPS : {results['avg_write_qps']:>10,.1f}")
print(f"  Average Total QPS : {results['avg_total_qps']:>10,.1f}")
print()
print(f"  Peak Read  QPS    : {results['peak_read_qps']:>10,.1f}  <-- design your read path for this")
print(f"  Peak Write QPS    : {results['peak_write_qps']:>10,.1f}  <-- design your write path for this")
print(f"  Peak Total QPS    : {results['peak_total_qps']:>10,.1f}")
print()
print(f"  Read/Write Ratio  : {results['read_write_ratio']:>10.1f}x  <-- heavy read bias → caching is critical")

# Traffic Pattern Simulator — visualises how QPS changes over 24 hours
# Shows WHY designing for average QPS is dangerous

import math

def hourly_traffic_multiplier(hour_of_day: int) -> float:
    """
    Returns a multiplier representing relative traffic at a given hour.
    Models a typical US consumer app's diurnal (time-of-day) traffic pattern.
    Hour 0 = midnight, Hour 12 = noon, Hour 20 = 8pm (typical peak).
    """
    # A sine wave centred at 8pm (hour 20), scaled so peak = ~3x, trough = ~0.2x
    # This is a simplified but realistic approximation of real traffic curves
    phase_shift = (hour_of_day - 20) * (math.pi / 12)  # shift peak to 8pm
    raw_wave = math.cos(phase_shift)                    # -1 to +1
    multiplier = 1.6 + (1.4 * raw_wave)                # scale to 0.2x – 3.0x range
    return max(0.1, multiplier)                         # floor at 0.1x (never zero traffic)


AVERAGE_QPS = 20_833  # from our previous estimation for the Twitter-like app

print("Hour | Multiplier | Actual QPS  | Safe to provision at average? ")
print("-" * 65)

for hour in range(24):
    multiplier = hourly_traffic_multiplier(hour)
    actual_qps = AVERAGE_QPS * multiplier
    at_capacity = actual_qps > AVERAGE_QPS  # True means average provisioning is insufficient
    danger_flag = "⚠ OVERLOADED" if at_capacity else "  OK"

    print(f"  {hour:02d}:00 |  {multiplier:5.2f}x     | {actual_qps:>10,.0f}  | {danger_flag}")

print()
print(f"Average QPS (baseline):  {AVERAGE_QPS:>10,}")
peak_hour_qps = AVERAGE_QPS * hourly_traffic_multiplier(20)
print(f"Peak hour QPS (8pm):     {peak_hour_qps:>10,.0f}")
print(f"Peak-to-average ratio:   {peak_hour_qps / AVERAGE_QPS:>10.1f}x")
print()
print("Conclusion: provisioning for average QPS means your system is")
print("overloaded for roughly 8 hours every single day.")

# Storage Growth Estimator — connects write QPS to long-term storage needs
# This is the calculation interviewers want to see AFTER you state your write QPS

def estimate_storage_growth(
    peak_write_qps: float,
    avg_record_size_bytes: int,
    replication_factor: int = 3,
    index_overhead_pct: float = 0.30,
    projection_years: int = 3
) -> None:
    """
    Given a write QPS, calculates raw and replicated storage growth over time.
    replication_factor: how many copies of each write are stored (e.g., 3 for most distributed DBs)
    index_overhead_pct: extra space consumed by DB indexes (30% is a safe default for B-tree indexes)
    """
    SECONDS_PER_DAY  = 86_400
    BYTES_PER_GB     = 1_073_741_824  # 1024^3 — using binary GiB for accuracy
    BYTES_PER_TB     = BYTES_PER_GB * 1_024

    # Raw bytes written per second (before replication)
    raw_bytes_per_second = peak_write_qps * avg_record_size_bytes

    # Total bytes on disk per second — accounts for all replicas
    replicated_bytes_per_second = raw_bytes_per_second * replication_factor

    # Add index overhead on top of replicated data
    total_bytes_per_second = replicated_bytes_per_second * (1 + index_overhead_pct)

    print(f"=== Storage Growth Estimation ===")
    print(f"Peak Write QPS       : {peak_write_qps:>12,.0f} writes/sec")
    print(f"Avg Record Size      : {avg_record_size_bytes:>12,} bytes")
    print(f"Replication Factor   : {replication_factor:>12}x")
    print(f"Index Overhead       : {index_overhead_pct*100:>11.0f}%")
    print()
    print(f"Raw write throughput : {raw_bytes_per_second/1_000_000:>11.1f} MB/sec")
    print(f"Total disk write rate: {total_bytes_per_second/1_000_000:>11.1f} MB/sec  (with replication + indexes)")
    print()

    print(f"{'Period':<12} | {'Raw Storage':>14} | {'With Replication + Index':>24}")
    print("-" * 58)

    for period_label, seconds in [
        ("1 Day",   SECONDS_PER_DAY),
        ("1 Month", SECONDS_PER_DAY * 30),
        ("1 Year",  SECONDS_PER_DAY * 365),
        (f"{projection_years} Years", SECONDS_PER_DAY * 365 * projection_years),
    ]:
        raw_total    = raw_bytes_per_second       * seconds
        on_disk_total = total_bytes_per_second    * seconds

        # Format in human-readable units
        raw_str     = f"{raw_total    / BYTES_PER_TB:.2f} TB" if raw_total     > BYTES_PER_TB else f"{raw_total    / BYTES_PER_GB:.1f} GB"
        on_disk_str = f"{on_disk_total / BYTES_PER_TB:.2f} TB" if on_disk_total > BYTES_PER_TB else f"{on_disk_total / BYTES_PER_GB:.1f} GB"

        print(f"{period_label:<12} | {raw_str:>14} | {on_disk_str:>24}")

    print()
    print("Architecture implications:")
    yearly_tb = (total_bytes_per_second * SECONDS_PER_DAY * 365) / BYTES_PER_TB
    if yearly_tb < 10:
        print("  → Single-region storage likely sufficient for year 1")
    elif yearly_tb < 100:
        print("  → Plan for sharding or partitioning by end of year 1")
    else:
        print("  → Distributed storage (e.g. Cassandra, S3 + data lake) required from day 1")


# Using the write QPS from our Twitter-like example: 10,417 peak writes/sec
# Tweet record: ~300 bytes (tweet text + user_id + timestamp + metadata)
estimate_storage_growth(
    peak_write_qps=10_417,
    avg_record_size_bytes=300,
    replication_factor=3,
    index_overhead_pct=0.30,
    projection_years=3
)