Bandwidth Estimation — When 10% DAU Math Fails

# ─────────────────────────────────────────────────────────────
# BandwidthEstimator.py
# A structured bandwidth estimation calculator that mirrors
# the thought process you'd use in a system design interview.
# ─────────────────────────────────────────────────────────────

def estimate_bandwidth(
    daily_active_users: int,
    concurrent_user_fraction: float,   # e.g. 0.10 = 10% online at once
    peak_traffic_multiplier: float,    # e.g. 3.0 = peak is 3× average
    avg_requests_per_user_per_second: float,  # how often a user triggers a request
    avg_payload_size_bytes: int        # average size of one request+response round trip
) -> dict:
    """
    Returns a breakdown of bandwidth at average and peak load.
    All output is in Megabits per second (Mbps) — the standard unit
    used when talking to network engineers and cloud providers.
    """

    # Step 1: How many users are active at the same moment?
    average_concurrent_users = daily_active_users * concurrent_user_fraction
    peak_concurrent_users    = average_concurrent_users * peak_traffic_multiplier

    # Step 2: Total requests per second across all concurrent users
    average_requests_per_second = average_concurrent_users * avg_requests_per_user_per_second
    peak_requests_per_second    = peak_concurrent_users    * avg_requests_per_user_per_second

    # Step 3: Convert to bytes per second, then bits per second, then Megabits per second
    # 1 byte = 8 bits; 1 Megabit = 1,000,000 bits  (use 1,000 not 1,024 for network bandwidth)
    bytes_to_megabits = 8 / 1_000_000

    average_bandwidth_mbps = average_requests_per_second * avg_payload_size_bytes * bytes_to_megabits
    peak_bandwidth_mbps    = peak_requests_per_second    * avg_payload_size_bytes * bytes_to_megabits

    # Step 4: Add a 20% overhead buffer for protocol headers, retransmissions, TLS handshakes
    overhead_factor = 1.20
    average_bandwidth_with_overhead_mbps = average_bandwidth_mbps * overhead_factor
    peak_bandwidth_with_overhead_mbps    = peak_bandwidth_mbps    * overhead_factor

    return {
        "average_concurrent_users":             int(average_concurrent_users),
        "peak_concurrent_users":                int(peak_concurrent_users),
        "average_requests_per_second":          round(average_requests_per_second, 1),
        "peak_requests_per_second":             round(peak_requests_per_second, 1),
        "average_bandwidth_mbps":               round(average_bandwidth_mbps, 2),
        "peak_bandwidth_mbps":                  round(peak_bandwidth_mbps, 2),
        "peak_bandwidth_with_overhead_mbps":    round(peak_bandwidth_with_overhead_mbps, 2),
        "recommended_provision_mbps":           round(peak_bandwidth_with_overhead_mbps * 1.25, 2)
        # Provision 25% above peak-with-overhead so you're never at 100% utilisation
    }


# ─────────────────────────────────────────────────────────────
# EXAMPLE: Estimating bandwidth for a photo-sharing app
# similar to early Instagram (upload + feed browsing)
# ─────────────────────────────────────────────────────────────

photo_app_estimate = estimate_bandwidth(
    daily_active_users              = 5_000_000,   # 5 million DAU
    concurrent_user_fraction        = 0.10,        # 10% active at once during the day
    peak_traffic_multiplier         = 3.0,         # 3× surge during evening peak hours
    avg_requests_per_user_per_second= 0.05,        # one request every 20 seconds (browsing feed)
    avg_payload_size_bytes          = 120_000      # ~120 KB per feed item (compressed image + metadata)
)

print("══════════════════════════════════════════")
print(" Bandwidth Estimation — Photo Sharing App")
print("══════════════════════════════════════════")
for metric, value in photo_app_estimate.items():
    label = metric.replace("_", " ").title()
    unit  = "Mbps" if "mbps" in metric else "users" if "users" in metric else "req/s"
    print(f"  {label:<45} {value:>12} {unit}")
print("══════════════════════════════════════════")

# ─────────────────────────────────────────────────────────────
# ReadWriteBandwidthSplit.py
# Models ingress (write) and egress (read) bandwidth separately.
# Based on a social video platform — think TikTok-scale estimates.
# ─────────────────────────────────────────────────────────────

from dataclasses import dataclass

@dataclass
class UserAction:
    name: str
    requests_per_active_user_per_day: float
    avg_payload_bytes: int
    direction: str  # "ingress" or "egress"

def bandwidth_from_actions(
    daily_active_users: int,
    concurrent_fraction: float,
    peak_multiplier: float,
    actions: list
) -> None:
    """
    Breaks down bandwidth per action type and summarises
    total ingress vs egress at peak load.
    """
    seconds_per_day        = 86_400
    concurrent_users       = daily_active_users * concurrent_fraction
    peak_concurrent_users  = concurrent_users * peak_multiplier
    bytes_to_mbps          = 8 / 1_000_000

    print(f"\nDAU: {daily_active_users:,}  |  Avg Concurrent: {int(concurrent_users):,}  |  Peak Concurrent: {int(peak_concurrent_users):,}")
    print(f"{'─'*80}")
    print(f"{'Action':<30} {'Direction':<10} {'Req/s (peak)':>14} {'Bandwidth (Mbps)':>18}")
    print(f"{'─'*80}")

    total_ingress_mbps = 0.0
    total_egress_mbps  = 0.0

    for action in actions:
        # Convert daily requests per user into requests per second
        requests_per_user_per_second = action.requests_per_active_user_per_day / seconds_per_day

        # Scale by peak concurrent users
        peak_requests_per_second = peak_concurrent_users * requests_per_user_per_second

        # Bandwidth in Megabits per second
        bandwidth_mbps = peak_requests_per_second * action.avg_payload_bytes * bytes_to_mbps

        print(f"{action.name:<30} {action.direction:<10} {peak_requests_per_second:>14,.0f} {bandwidth_mbps:>17,.1f}")

        if action.direction == "ingress":
            total_ingress_mbps += bandwidth_mbps
        else:
            total_egress_mbps  += bandwidth_mbps

    print(f"{'─'*80}")
    print(f"{'TOTAL INGRESS (upload)':<30} {'':10} {'':>14} {total_ingress_mbps:>17,.1f} Mbps")
    print(f"{'TOTAL EGRESS (download)':<30} {'':10} {'':>14} {total_egress_mbps:>17,.1f} Mbps")
    read_write_ratio = total_egress_mbps / total_ingress_mbps if total_ingress_mbps > 0 else float('inf')
    print(f"\n  Read-to-Write Ratio: {read_write_ratio:.0f}:1")
    print(f"  Egress is {read_write_ratio:.0f}× higher — size your egress pipe accordingly.")


# ─────────────────────────────────────────────────────────────
# Social Video Platform — similar scale to early TikTok
# ─────────────────────────────────────────────────────────────

platform_actions = [
    UserAction(
        name                              = "Video Upload (60s clip)",
        requests_per_active_user_per_day  = 0.5,          # half of users upload once a day
        avg_payload_bytes                 = 50_000_000,   # 50 MB compressed video
        direction                         = "ingress"
    ),
    UserAction(
        name                              = "Video Stream (watch)",
        requests_per_active_user_per_day  = 120,          # 120 videos watched per day
        avg_payload_bytes                 = 5_000_000,    # 5 MB per streamed video segment batch
        direction                         = "egress"
    ),
    UserAction(
        name                              = "Feed API Request",
        requests_per_active_user_per_day  = 60,           # refresh feed ~60 times per day
        avg_payload_bytes                 = 15_000,       # 15 KB JSON metadata per feed load
        direction                         = "egress"
    ),
    UserAction(
        name                              = "Comment / Like Submit",
        requests_per_active_user_per_day  = 30,
        avg_payload_bytes                 = 500,          # tiny JSON payload
        direction                         = "ingress"
    ),
]

bandwidth_from_actions(
    daily_active_users  = 10_000_000,   # 10M DAU
    concurrent_fraction = 0.08,         # 8% concurrent
    peak_multiplier     = 4.0,          # 4× peak (viral video moment)
    actions             = platform_actions
)

# ─────────────────────────────────────────────────────────────
# BandwidthSanityChecker.py
# Validates a bandwidth estimate against known reference points
# and flags results that are implausible.
# ─────────────────────────────────────────────────────────────

from enum import Enum

class AppType(Enum):
    TEXT_API      = ("Text / API heavy",          10_000,      5_000_000)       # 10 Kbps – 5 Mbps per user
    IMAGE_FEED    = ("Image feed / social",        500_000,     50_000_000)      # 500 Kbps – 50 Mbps per user
    VIDEO_SD      = ("SD Video Streaming",         1_000_000,   5_000_000)       # 1 Mbps – 5 Mbps per user
    VIDEO_HD_4K   = ("HD/4K Video Streaming",      5_000_000,   25_000_000)      # 5 Mbps – 25 Mbps per user

    def __init__(self, label, min_bps_per_user, max_bps_per_user):
        self.label               = label
        self.min_bps_per_user    = min_bps_per_user
        self.max_bps_per_user    = max_bps_per_user


# Known infrastructure reference points (in Mbps)
INFRASTRUCTURE_TIERS = [
    ("1 GbE server NIC",           1_000),
    ("10 GbE server NIC",         10_000),
    ("25 GbE link",               25_000),
    ("100 GbE top-of-rack port", 100_000),
    ("400 GbE backbone link",    400_000),
    ("1 Tbps backbone",        1_000_000),
]


def sanity_check(
    estimated_total_bandwidth_mbps: float,
    peak_concurrent_users: int,
    app_type: AppType
) -> None:
    """
    Checks whether a bandwidth estimate makes sense by:
    1. Calculating per-user bandwidth and checking against known ranges
    2. Mapping total bandwidth to physical infrastructure units
    """

    print("\n" + "═" * 60)
    print(" BANDWIDTH SANITY CHECK")
    print("═" * 60)
    print(f"  App type:              {app_type.label}")
    print(f"  Total bandwidth:       {estimated_total_bandwidth_mbps:,.1f} Mbps")
    print(f"  Peak concurrent users: {peak_concurrent_users:,}")

    # ── Check 1: Per-user bandwidth ───────────────────────────
    # Convert total Mbps to bits per second, divide per user
    total_bps           = estimated_total_bandwidth_mbps * 1_000_000
    bps_per_user        = total_bps / peak_concurrent_users
    mbps_per_user       = bps_per_user / 1_000_000

    min_expected_bps    = app_type.min_bps_per_user
    max_expected_bps    = app_type.max_bps_per_user

    print(f"\n  Per-user bandwidth:    {mbps_per_user:.3f} Mbps")
    print(f"  Expected range:        {min_expected_bps/1_000_000:.3f} – {max_expected_bps/1_000_000:.1f} Mbps")

    if bps_per_user < min_expected_bps:
        print("  ⚠️  BELOW RANGE — Estimate may be too low. Check payload sizes.")
    elif bps_per_user > max_expected_bps:
        print("  ⚠️  ABOVE RANGE — Estimate may be too high. Check request frequency.")
    else:
        print("  ✅  Per-user bandwidth is within expected range.")

    # ── Check 2: Map to infrastructure ───────────────────────
    print("\n  Infrastructure mapping:")
    infrastructure_needed = None
    for infra_name, infra_capacity_mbps in INFRASTRUCTURE_TIERS:
        links_needed = estimated_total_bandwidth_mbps / infra_capacity_mbps
        if links_needed <= 10:   # Flag the first tier that needs 10 or fewer links
            infrastructure_needed = (infra_name, links_needed)
            print(f"    → Requires {links_needed:.1f}× {infra_name} links")
            break
    if infrastructure_needed is None:
        print("    → Exceeds 400 GbE — you need a multi-Tbps backbone. Double-check inputs.")

    print("═" * 60)


# ── Example 1: Reasonable estimate for an image-heavy social app ──
sanity_check(
    estimated_total_bandwidth_mbps = 108_000,
    peak_concurrent_users          = 1_500_000,
    app_type                       = AppType.IMAGE_FEED
)

# ── Example 2: A suspiciously high estimate — let's see it flagged ──
sanity_check(
    estimated_total_bandwidth_mbps = 5_000_000,
    peak_concurrent_users          = 10_000,
    app_type                       = AppType.TEXT_API
)

# ─────────────────────────────────────────────────────────────
# YouTubeInterviewEstimate.py
# End-to-end bandwidth estimation for a YouTube-scale system.
# Shows the complete thought process you'd walk through out loud
# in a system design interview — no shortcuts.
# ─────────────────────────────────────────────────────────────

def youtube_scale_estimation():

    # ── INPUTS: State assumptions explicitly ─────────────────
    daily_active_users          = 80_000_000   # 80M DAU (known public figure)
    uploader_fraction           = 0.005        # 0.5% of DAU upload content
    avg_upload_size_bytes       = 500_000_000  # 500 MB per uploaded video (pre-transcoding)
    avg_videos_watched_per_day  = 5            # each user watches 5 videos
    avg_stream_rate_mbps        = 2.5          # mix of 360p, 720p, 1080p = avg ~2.5 Mbps
    concurrent_fraction         = 0.10         # 10% of DAU active at once
    peak_multiplier             = 3.0          # 3× surge in evening hours
    cdn_offload_fraction        = 0.90         # CDN absorbs 90% of view traffic
    bytes_to_mbps               = 8 / 1_000_000
    seconds_per_day             = 86_400

    print("\n" + "═" * 65)
    print(" YOUTUBE-SCALE BANDWIDTH ESTIMATION — INTERVIEW WALKTHROUGH")
    print("═" * 65)

    # ── WRITE (INGRESS): Upload bandwidth ────────────────────
    uploaders_per_day          = daily_active_users * uploader_fraction
    upload_bytes_per_second    = (uploaders_per_day * avg_upload_size_bytes) / seconds_per_day
    ingress_bandwidth_mbps     = upload_bytes_per_second * bytes_to_mbps

    print(f"\n📤 INGRESS (Uploads)")
    print(f"   Uploaders per day:         {uploaders_per_day:>12,.0f}")
    print(f"   Upload data rate:          {ingress_bandwidth_mbps:>12,.1f} Mbps")

    # ── READ (EGRESS): Streaming bandwidth ───────────────────
    # Average concurrent viewers across the day
    avg_concurrent_viewers     = daily_active_users * concurrent_fraction

    # Peak concurrent viewers (evening surge)
    peak_concurrent_viewers    = avg_concurrent_viewers * peak_multiplier

    # Total egress at peak: every concurrent viewer is streaming
    total_egress_peak_mbps     = peak_concurrent_viewers * avg_stream_rate_mbps
    total_egress_peak_tbps     = total_egress_peak_mbps / 1_000_000  # convert to Tbps

    print(f"\n📥 EGRESS (Streaming)")
    print(f"   Avg concurrent viewers:   {avg_concurrent_viewers:>12,.0f}")
    print(f"   Peak concurrent viewers:  {peak_concurrent_viewers:>12,.0f}")
    print(f"   Total egress at peak:     {total_egress_peak_mbps:>12,.0f} Mbps  ({total_egress_peak_tbps:.1f} Tbps)")

    # ── CDN OFFLOADING ────────────────────────────────────────
    # Popular videos are cached at edge nodes; origin only handles the rest
    origin_egress_mbps         = total_egress_peak_mbps * (1 - cdn_offload_fraction)
    cdn_egress_mbps            = total_egress_peak_mbps * cdn_offload_fraction

    print(f"\n🌐 CDN OFFLOADING (90% cache hit rate)")
    print(f"   CDN handles:              {cdn_egress_mbps:>12,.0f} Mbps")
    print(f"   Origin servers handle:    {origin_egress_mbps:>12,.0f} Mbps")

    # ── INFRASTRUCTURE SIZING ─────────────────────────────────
    link_capacity_mbps         = 400_000     # 400 GbE backbone link
    origin_links_needed        = origin_egress_mbps / link_capacity_mbps

    print(f"\n🖥️  ORIGIN INFRASTRUCTURE SIZING")
    print(f"   Link capacity used:       400 GbE per link")
    print(f"   Links needed (origin):    {origin_links_needed:>12.1f} × 400 GbE links")
    print(f"   (Plus redundancy: provision 2× = {origin_links_needed*2:.0f} links)")

    # ── SANITY CHECK ──────────────────────────────────────────
    # YouTube ≈ 15% of ~700 Tbps global internet traffic
    global_internet_tbps       = 700
    youtube_share_fraction     = 0.15
    expected_youtube_tbps      = global_internet_tbps * youtube_share_fraction
    our_estimate_tbps          = total_egress_peak_tbps
    error_factor               = abs(our_estimate_tbps - expected_youtube_tbps) / expected_youtube_tbps

    print(f"\n✅ SANITY CHECK")
    print(f"   Our estimate:             {our_estimate_tbps:>12.1f} Tbps")
    print(f"   Expected (~15% of 700T):  {expected_youtube_tbps:>12.1f} Tbps")
    print(f"   Deviation:                {error_factor*100:>12.1f}%  {'✅ Within 2× — reasonable!' if error_factor < 1.0 else '⚠️ Off by more than 2× — revisit assumptions'}")
    print("═" * 65)


youtube_scale_estimation()

# ─────────────────────────────────────────────────────────────
# ProtocolOverheadCalculator.py
# Shows how protocol headers inflate bandwidth for different payload sizes.
# Useful for adjusting your raw payload estimate before provisioning.
# ─────────────────────────────────────────────────────────────

def overhead_factor(payload_bytes: int, use_tls=True) -> float:
    """
    Estimates the overhead multiplier for a single packet.
    Assumes one request per TCP connection.
    """
    tcp_overhead = 40  # TCP + IP headers
    tls_overhead = 40  # TLS record overhead (approximate)
    total_header = tcp_overhead + (tls_overhead if use_tls else 0)
    return (payload_bytes + total_header) / payload_bytes


def print_overhead_table(payloads: list):
    print(f"\n{'Payload Size':<20} {'No TLS':<15} {'With TLS':<15} {'Effective Overhead %':<25}")
    print("-" * 75)
    for p in payloads:
        no_tls = overhead_factor(p, use_tls=False)
        with_tls = overhead_factor(p, use_tls=True)
        eff_overhead = (with_tls - 1) * 100
        print(f"{p:<20} {no_tls:<15.2f} {with_tls:<15.2f} {eff_overhead:<25.1f}%")


print("Protocol Overhead Impact on Bandwidth")
print_overhead_table([64, 256, 1024, 8192, 65536, 1_000_000])

# ── Example: 1 million requests per second, 1 KB payload, with TLS ──
payload = 1024  # 1 KB
req_sec = 1_000_000
overhead = overhead_factor(payload, use_tls=True)
effective_bps = req_sec * payload * 8 * overhead  # bits per second
print(f"\nFor {req_sec:,} req/s with 1 KB payload and TLS:")
print(f"  Raw bitrate: {req_sec * payload * 8 / 1e6:.0f} Mbps")
print(f"  With overhead: {effective_bps / 1e6:.0f} Mbps (adds {round((overhead-1)*100)}% more)")

// io.thecodeforge
package main

import (
	"fmt"
	"sort"
)

// BandwidthSample holds bytes transferred and duration for a single measurement.
type BandwidthSample struct {
	Bytes    int64
	Duration float64 // seconds
}

// Bps converts a sample to bytes per second.
func (s BandwidthSample) Bps() float64 {
	return float64(s.Bytes) / s.Duration
}

// ComputePercentile sorts samples, returns bps at given percentile (0-100).
func ComputePercentile(samples []BandwidthSample, p float64) float64 {
	if len(samples) == 0 {
		return 0
	}
	sort.Slice(samples, func(i, j int) bool {
		return samples[i].Bps() < samples[j].Bps()
	})
	idx := int(float64(len(samples)-1) * p / 100.0)
	return samples[idx].Bps()
}

func main() {
	data := []BandwidthSample{
		{Bytes: 10485760, Duration: 1.0},   // 10 MB in 1s
		{Bytes: 20971520, Duration: 0.5},   // 20 MB in 0.5s -> 40 MB/s spike
		{Bytes: 5242880, Duration: 10.0},   // 5 MB in 10s -> 0.5 MB/s quiet
	}
	fmt.Printf("95th percentile: %.2f MB/s\n", ComputePercentile(data, 95)/1e6)
}

// io.thecodeforge
import java.time.Instant;
import java.util.*;

/**
 * Estimates required bandwidth given peak concurrency and average stream bitrate.
 */
public class BandwidthEstimator {

    record Connection(long startEpoch, long endEpoch, int bitrateMbps) {}

    static double estimateRequiredMbps(List<Connection> conns) {
        // Find max concurrent bitrate using sweep line
        var events = new ArrayList<Map.Entry<Long, Integer>>();
        for (var c : conns) {
            events.add(Map.entry(c.startEpoch, c.bitrateMbps));
            events.add(Map.entry(c.endEpoch, -c.bitrateMbps));
        }
        events.sort(Map.Entry.comparingByKey());
        int current = 0, peak = 0;
        for (var e : events) {
            current += e.getValue();
            peak = Math.max(peak, current);
        }
        return peak * 1.1; // +10% TCP overhead
    }

    public static void main(String[] args) {
        var now = Instant.now().getEpochSecond();
        var sample = List.of(
            new Connection(now, now+60, 25),  // 25 Mbps for 60s
            new Connection(now+10, now+20, 50) // spike: 50 Mbps overlap
        );
        System.out.printf("Required bandwidth: %.0f Mbps%n", estimateRequiredMbps(sample));
    }
}