1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

# Bandwidth calculation for Instagram-like platform
 
# Traffic metrics (from traffic estimation)
daily_active_users = 500_000_000  # 500M DAU
sessions_per_user = 7             # Opens app 7 times/day
feed_scrolls_per_session = 10    # Scrolls feed 10 times
images_per_scroll = 6            # 6 images load per scroll
 
# Calculate total image views per day
total_image_views = (daily_active_users * sessions_per_user * 
                     feed_scrolls_per_session * images_per_scroll)
print(f"Daily image views: {total_image_views / 1e12:.1f} trillion")
 
# Image sizes (different based on context)
# Feed view: optimized, smaller
# Full view: high resolution
average_feed_image_kb = 150  # Optimized for feed
full_view_ratio = 0.20       # 20% of images are clicked for full view
full_view_image_kb = 500     # Higher resolution
 
# Calculate egress bandwidth (images downloaded)
feed_egress_bytes = total_image_views * average_feed_image_kb * 1024
full_view_egress_bytes = (total_image_views * full_view_ratio * 
                          full_view_image_kb * 1024)
total_daily_egress = feed_egress_bytes + full_view_egress_bytes
 
print(f"
Daily egress (images only): {total_daily_egress / 1e15:.2f} PB")
 
# Convert to bandwidth
seconds_per_day = 86400
average_bits_per_second = (total_daily_egress * 8) / seconds_per_day
average_gbps = average_bits_per_second / 1e9
 
print(f"Average bandwidth: {average_gbps:.0f} Gbps")
 
# Peak bandwidth (3x average during peak hours)
peak_bandwidth_gbps = average_gbps * 3
print(f"Peak bandwidth: {peak_bandwidth_gbps:.0f} Gbps ({peak_bandwidth_gbps/1000:.1f} Tbps)")
 
# Ingress (users uploading)
photos_uploaded_per_day = 100_000_000  # 100M photos/day
average_upload_size_mb = 5              # Before compression
ingress_bytes_per_day = photos_uploaded_per_day * average_upload_size_mb * 1e6
ingress_gbps = (ingress_bytes_per_day * 8) / seconds_per_day / 1e9
 
print(f"
Ingress bandwidth: {ingress_gbps:.0f} Gbps")
print(f"Egress:Ingress ratio: {average_gbps/ingress_gbps:.0f}:1")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

# Protocol overhead comparison
 
import json
from dataclasses import dataclass
from typing import List
 
@dataclass
class User:
    id: int
    username: str
    display_name: str
    avatar_url: str
    followers_count: int
    following_count: int
    is_verified: bool
    created_at: str
 
# Sample user
user = User(
    id=123456789012345678,
    username="techleader",
    display_name="Tech Leader",
    avatar_url="https://cdn.example.com/avatars/123456789012345678.jpg",
    followers_count=125000,
    following_count=892,
    is_verified=True,
    created_at="2019-03-15T10:30:00Z"
)
 
# JSON representation
json_data = json.dumps({
    "id": user.id,
    "username": user.username,
    "display_name": user.display_name,
    "avatar_url": user.avatar_url,
    "followers_count": user.followers_count,
    "following_count": user.following_count,
    "is_verified": user.is_verified,
    "created_at": user.created_at
})
 
print(f"JSON size: {len(json_data)} bytes")
print(f"JSON content:
{json_data}
")
 
# Protobuf would be approximately:
# - id: 8 bytes (varint)
# - username: 11 bytes (length + string)
# - display_name: 12 bytes
# - avatar_url: 55 bytes
# - counters: 6 bytes (varints)
# - bool: 1 byte
# - timestamp: 8 bytes
# - field tags: ~15 bytes
protobuf_estimate = 8 + 11 + 12 + 55 + 6 + 1 + 8 + 15
print(f"Protobuf estimate: {protobuf_estimate} bytes")
print(f"Savings: {(1 - protobuf_estimate/len(json_data))*100:.0f}%")
 
# At scale
requests_per_second = 100_000
json_bandwidth_mbps = requests_per_second * len(json_data) * 8 / 1e6
protobuf_bandwidth_mbps = requests_per_second * protobuf_estimate * 8 / 1e6
 
print(f"
At 100K RPS:")
print(f"JSON bandwidth: {json_bandwidth_mbps:.0f} Mbps")
print(f"Protobuf bandwidth: {protobuf_bandwidth_mbps:.0f} Mbps")
print(f"Bandwidth saved: {json_bandwidth_mbps - protobuf_bandwidth_mbps:.0f} Mbps")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

# Peak bandwidth planning for live streaming event
 
# Event parameters
expected_concurrent_viewers = 10_000_000  # 10M concurrent
peak_concurrent_viewers = 15_000_000      # Peak moment (goal scored, etc.)
 
# Quality distribution
quality_distribution = {
    "1080p": (0.30, 8),    # 30% of viewers, 8 Mbps
    "720p": (0.40, 5),     # 40% of viewers, 5 Mbps
    "480p": (0.20, 2.5),   # 20% of viewers, 2.5 Mbps
    "360p": (0.10, 1),     # 10% of viewers, 1 Mbps
}
 
def calculate_bandwidth(viewers: int) -> float:
    """Calculate total bandwidth in Tbps"""
    total_mbps = 0
    for quality, (fraction, bitrate) in quality_distribution.items():
        viewers_at_quality = viewers * fraction
        bandwidth_mbps = viewers_at_quality * bitrate
        total_mbps += bandwidth_mbps
        print(f"  {quality}: {viewers_at_quality/1e6:.1f}M viewers × {bitrate} Mbps = {bandwidth_mbps/1e6:.1f} Tbps")
    return total_mbps / 1e6  # Convert to Tbps
 
print("Expected concurrent bandwidth:")
expected_tbps = calculate_bandwidth(expected_concurrent_viewers)
print(f"  Total: {expected_tbps:.1f} Tbps")
 
print("
Peak moment bandwidth:")
peak_tbps = calculate_bandwidth(peak_concurrent_viewers)
print(f"  Total: {peak_tbps:.1f} Tbps")
 
# CDN requirements
# Assume CDN can deliver 100 Gbps per PoP on average
# Need geographic distribution for latency
pops_needed = (peak_tbps * 1000) / 100  # Convert Tbps to Gbps, divide by PoP capacity
print(f"
CDN Points of Presence needed: {pops_needed:.0f}+")
 
# Buffer for safety (1.5x)
safe_capacity = peak_tbps * 1.5
print(f"Reserved CDN capacity (with 50% buffer): {safe_capacity:.1f} Tbps")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

# CDN bandwidth modeling for video platform
 
# Total egress requirements (from previous calculations)
total_egress_gbps = 10_000  # 10 Tbps total
 
# Content breakdown and cache characteristics
content_types = {
    "video_popular_10pct": {
        "traffic_share": 0.50,    # Top 10% of videos = 50% of traffic
        "cache_hit_ratio": 0.95,  # Very cacheable
    },
    "video_long_tail": {
        "traffic_share": 0.30,    # Rest of videos = 30% of traffic
        "cache_hit_ratio": 0.60,  # Less cacheable
    },
    "thumbnails_images": {
        "traffic_share": 0.10,    # Images
        "cache_hit_ratio": 0.98,  # Highly cacheable
    },
    "api_responses": {
        "traffic_share": 0.08,    # API data
        "cache_hit_ratio": 0.40,  # Partially cacheable
    },
    "real_time": {
        "traffic_share": 0.02,    # Metrics, live features
        "cache_hit_ratio": 0.00,  # Never cached
    },
}
 
# Calculate bandwidth by layer
cdn_egress = 0
origin_egress = 0
 
print("Bandwidth Distribution:")
print("=" * 60)
 
for content_type, metrics in content_types.items():
    type_bandwidth = total_egress_gbps * metrics["traffic_share"]
    type_origin = type_bandwidth * (1 - metrics["cache_hit_ratio"])
    type_cdn = type_bandwidth * metrics["cache_hit_ratio"]
    
    cdn_egress += type_cdn
    origin_egress += type_origin
    
    print(f"{content_type}:")
    print(f"  Total: {type_bandwidth:.0f} Gbps | "
          f"CDN: {type_cdn:.0f} Gbps | Origin: {type_origin:.0f} Gbps")
 
print("=" * 60)
print(f"Total CDN egress: {cdn_egress:.0f} Gbps ({cdn_egress/total_egress_gbps*100:.1f}%)")
print(f"Total Origin egress: {origin_egress:.0f} Gbps ({origin_egress/total_egress_gbps*100:.1f}%)")
print(f"
Origin bandwidth reduced by: {(1-origin_egress/total_egress_gbps)*100:.1f}%")
 
# Cost comparison (rough estimates)
cdn_cost_per_gb = 0.01       # $0.01/GB for CDN (committed pricing)
origin_cost_per_gb = 0.085   # $0.085/GB for cloud egress
 
# Monthly data volume (assuming 10 Tbps average = 3.2 EB/month)
monthly_cdn_gb = cdn_egress * 3600 * 24 * 30 * 0.125  # Gbps to GB/month
monthly_origin_gb = origin_egress * 3600 * 24 * 30 * 0.125
 
cdn_monthly_cost = monthly_cdn_gb * cdn_cost_per_gb / 1e6  # In millions
origin_monthly_cost = monthly_origin_gb * origin_cost_per_gb / 1e6
 
print(f"
Monthly bandwidth costs:")
print(f"  CDN: ${cdn_monthly_cost: .1f
                            }M")
print(f"  Origin: ${origin_monthly_cost:.1f}M")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# Network cost calculation for a growing startup
 
def calculate_monthly_egress_cost(
                                monthly_egress_tb: float,
                                pricing_tiers: list = [
                                    (10, 0.09),      # First 10TB at $0.09 / GB
                                        (140, 0.085),    # Next 140TB at $0.085 / GB
                                            (350, 0.07),     # Next 350TB at $0.07 / GB
                                                (float('inf'), 0.05),  # Above that(negotiated)
                                ]
                            ) -> float:
                        """Calculate tiered egress cost"""
    remaining_tb = monthly_egress_tb
    total_cost = 0
    
    for tier_limit, price_per_gb in pricing_tiers:
                        tb_in_tier = min(remaining_tb, tier_limit)
        gb_in_tier = tb_in_tier * 1024
        tier_cost = gb_in_tier * price_per_gb
        total_cost += tier_cost
        remaining_tb -= tb_in_tier
        
        if remaining_tb <= 0:
                    break
    
    return total_cost
 
# Startup growth scenario
scenarios =[
                        ("Seed Stage", 10),        # 10 TB / month
                            ("Series A", 100),         # 100 TB / month
                                ("Series B", 500),         # 500 TB / month
                                    ("Series C", 2000),        # 2 PB / month
                                        ("Scale", 10000),          # 10 PB / month
                    ]
 
print("Monthly Egress Costs by Growth Stage")
print("=" * 50)
for stage, tb in scenarios:
                        cost = calculate_monthly_egress_cost(tb)
    cost_per_gb = cost / (tb * 1024) if tb > 0 else 0
    print(f"{stage}: {tb:,} TB → ${cost:,.0f}/month (${cost_per_gb:.4f}/GB avg)")
 
# Alternative: CDN pricing at scale
print("
With CDN (committed pricing at $0.01/GB):")
for stage, tb in scenarios:
                        cdn_cost = tb * 1024 * 0.01
    cloud_cost = calculate_monthly_egress_cost(tb)
    savings = cloud_cost - cdn_cost
    print(f"{stage}: CDN ${cdn_cost:,.0f} vs Cloud ${cloud_cost:,.0f} → Save ${savings:,.0f}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Sample interview calculation (video streaming platform)
 
"Let me estimate the bandwidth requirements for our video streaming service.
 
CONCURRENT USERS:
                - 50M DAU
                - 10 % concurrent during peak = 5M users
                - 60 % actively streaming = 3M streams
 
BANDWIDTH PER STREAM:
                - Average quality mix: 720p = 4 Mbps
                - Total user - facing: 3M × 4 Mbps = 12 Tbps
 
CDN LAYER:
                - CDN serves 95 % (popular content cached)
        - CDN egress: 12 Tbps × 0.95 = 11.4 Tbps
            - Origin egress: 12 Tbps × 0.05 = 600 Gbps
 
ORIGIN INFRASTRUCTURE:
    - 600 Gbps origin egress
        - With 3x headroom: ~2 Tbps origin capacity
            - At 100 Gbps per data center: 20 + data centers globally
 
    INGRESS(UPLOADS):
    - 100K creators uploading daily
        - Average 1 hour of content = 3GB(raw)
            - Total: 100K × 3GB = 300 TB / day
                - Ingress bandwidth: 300 TB / 86400s = ~28 Gbps
 
    SUMMARY:
    - Peak egress: 12 Tbps(CDN) + 600 Gbps(origin)
        - Peak ingress: ~30 Gbps
            - Egress:Ingress ratio ≈ 400: 1"