System Design Interview: Complete Preparation Guide

def gather_requirements():
    """Template for collecting system design requirements."""
    requirements = {
        "functional": [
            "Create shortened URLs",
            "Redirect to original URL",
            "Custom alias support",
            "Analytics (click count, referrer)",
            "URL expiration",
            "REST API for programmatic access",
        ],
        "non_functional": {
            "traffic": "100M URLs created/month",
            "reads": "10K redirects/second peak",
            "latency_p99_ms": 200,
            "availability": "99.99%",
            "consistency": "Eventual for analytics, strong for redirects"
        }
    }
    return requirements

reqs = gather_requirements()
print("Functional:", len(reqs["functional"]), "items")
print(f"Traffic: {reqs['non_functional']['traffic']}")
print(f"Redirects: {reqs['non_functional']['reads']}/s")

-- URL Shortener Schema
CREATE TABLE urls (
    short_key VARCHAR(10) PRIMARY KEY,
    original_url TEXT NOT NULL,
    user_id BIGINT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMP,
    click_count BIGINT DEFAULT 0
);

CREATE TABLE click_events (
    id BIGSERIAL PRIMARY KEY,
    short_key VARCHAR(10) REFERENCES urls(short_key),
    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    ip_address INET,
    user_agent TEXT,
    referrer TEXT
);

CREATE INDEX idx_click_events_short_key ON click_events(short_key);
CREATE INDEX idx_urls_user_id ON urls(user_id);

import time
import threading

class SnowflakeID:
    """Distributed unique ID generator (Twitter Snowflake-style)."""
    def __init__(self, worker_id, datacenter_id):
        self.worker_id = worker_id
        self.datacenter_id = datacenter_id
        self.sequence = 0
        self.last_timestamp = -1
        self.lock = threading.Lock()
    
    def _gen_timestamp(self):
        return int(time.time() * 1000)
    
    def get_id(self):
        with self.lock:
            timestamp = self._gen_timestamp()
            if timestamp == self.last_timestamp:
                self.sequence = (self.sequence + 1) & 4095
            else:
                self.sequence = 0
            self.last_timestamp = timestamp
            
            id = ((timestamp - 1609459200000) << 22)  # custom epoch
            id |= (self.datacenter_id << 17)
            id |= (self.worker_id << 12)
            id |= self.sequence
            return id

gen = SnowflakeID(worker_id=1, datacenter_id=1)
print(f"ID: {gen.get_id()}")
print(f"ID: {gen.get_id()}")

BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

def encode_base62(num):
    """Convert a number to base62 string."""
    if num == 0:
        return BASE62[0]
    result = []
    while num > 0:
        result.append(BASE62[num % 62])
        num //= 62
    return ''.join(reversed(result))

def decode_base62(s):
    """Convert base62 string back to number."""
    result = 0
    for char in s:
        result = result * 62 + BASE62.index(char)
    return result

# Test
ids = [0, 1, 61, 62, 123456789]
for id in ids:
    encoded = encode_base62(id)
    decoded = decode_base62(encoded)
    print(f"{id:>10} → {encoded:>7} → {decoded}")

from dataclasses import dataclass, field
from typing import List, Dict

@dataclass
class SystemDesign:
    """Template for practicing system design interviews."""
    problem: str
    requirements: Dict = field(default_factory=dict)
    estimation: Dict = field(default_factory=dict)
    data_model: str = ""
    high_level_design: List[str] = field(default_factory=list)
    deep_dive_topics: List[str] = field(default_factory=list)
    tradeoffs: List[tuple] = field(default_factory=list)
    
    def present(self):
        print(f"\n{'='*50}")
        print(f"SYSTEM DESIGN: {self.problem}")
        print(f"{'='*50}")
        print(f"\n📋 Requirements:")
        for k, v in self.requirements.items():
            print(f"   {k}: {v}")
        print(f"\n📊 Estimation:")
        for k, v in self.estimation.items():
            print(f"   {k}: {v}")
        print(f"\n🗄️  Data Model:")
        print(f"   {self.data_model}")
        print(f"\n🏗️  High-Level Components:")
        for c in self.high_level_design:
            print(f"   - {c}")
        print(f"\n🔍 Deep Dive:")
        for t in self.deep_dive_topics:
            print(f"   - {t}")
        print(f"\n⚖️  Tradeoffs:")
        for decision, alt, reason in self.tradeoffs:
            print(f"   {decision} over {alt}: {reason}")

design = SystemDesign(problem="URL Shortener")
design.requirements = {
    "functional": ["Create short URLs", "Redirect", "Analytics"],
    "non-functional": {"reads": "10K/s", "writes": "40/s", "latency": "<200ms"}
}
design.estimation = {"storage": "600 GB/year", "bandwidth": "15 TB/month"}
design.data_model = "PostgreSQL urls + click_events tables"
design.high_level_design = ["Load Balancer", "Web Servers", "Redis Cache", "PostgreSQL", "Kafka", "ClickHouse"]
design.deep_dive_topics = ["Key generation (Snowflake + Base62)", "Caching strategy", "Database sharding"]
design.tradeoffs = [
    ("PostgreSQL", "Cassandra", "Strong consistency needed"),
    ("Snowflake", "UUID", "Ordered, fits in 64-bit"),
    ("Monolith", "Microservices", "40 writes/sec, simpler ops"),
]
design.present()