Design a Real System

Base62 encoding (counter approach)

BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

def encode(n: int) -> str:
    """Encode a positive integer as a Base62 string."""
    if n == 0:
        return BASE62[0]
    chars = []
    while n:
        chars.append(BASE62[n % 62])
        n //= 62
    return "".join(reversed(chars))

# id=1     -> "1"
# id=62    -> "10"
# id=3844  -> "100"
# id=12345 -> "3D7"  (7 chars exhausted at id ~3.5 trillion)

async def create_short_url(long_url: str, user_id: int) -> str:
    row = await db.fetchrow(
        "INSERT INTO urls (long_url, user_id) VALUES ($1, $2) RETURNING id",
        long_url, user_id,
    )
    short_code = encode(row["id"])
    await db.execute(
        "UPDATE urls SET short_code = $1 WHERE id = $2",
        short_code, row["id"],
    )
    return short_code

PostgreSQL schema

CREATE TABLE urls (
    id          BIGSERIAL    PRIMARY KEY,
    short_code  VARCHAR(10)  NOT NULL UNIQUE,
    long_url    TEXT         NOT NULL,
    user_id     BIGINT       REFERENCES users(id) ON DELETE SET NULL,
    created_at  TIMESTAMPTZ  NOT NULL DEFAULT NOW(),
    expires_at  TIMESTAMPTZ  -- NULL means never expires
);

-- Hot path: every redirect does this lookup
CREATE INDEX idx_urls_short_code ON urls (short_code);

-- Dashboard queries: show a user their links
CREATE INDEX idx_urls_user_id ON urls (user_id, created_at DESC);

-- Background job: reap expired URLs
CREATE INDEX idx_urls_expires_at ON urls (expires_at)
    WHERE expires_at IS NOT NULL;

Cache invalidation on URL deletion

async def delete_url(short_code: str, user_id: int):
    # 1. Delete from DB (authoritative)
    deleted = await db.execute(
        "DELETE FROM urls WHERE short_code = $1 AND user_id = $2",
        short_code, user_id,
    )
    if not deleted:
        raise HTTPException(status_code=404)

    # 2. Invalidate Redis immediately
    await redis.delete(f"url:{short_code}")

    # 3. Purge CDN cache for this path (fire-and-forget)
    asyncio.create_task(cdn_purge(f"/{short_code}"))

Analytics pipeline: Kafka producer in the redirect handler

# Click event schema (Kafka message value)
@dataclass
class ClickEvent:
    short_code: str
    timestamp: datetime
    referrer: str | None
    user_agent: str
    ip_hash: str      # hashed, not raw IP (privacy)
    country: str      # resolved from IP at edge

async def emit_click_event(short_code: str, request: Request):
    event = ClickEvent(
        short_code=short_code,
        timestamp=datetime.now(UTC),
        referrer=request.headers.get("Referer"),
        user_agent=request.headers.get("User-Agent", ""),
        ip_hash=hash_ip(request.client.host),
        country=request.headers.get("CF-IPCountry", "XX"),  # CDN-injected
    )
    try:
        # Fire and forget, if Kafka is down, drop the event
        # Analytics loss is acceptable; redirect failure is not
        await kafka_producer.send("click_events", value=asdict(event))
    except Exception:
        pass  # never propagate analytics failures to the caller

# ClickHouse consumer (separate service):
# Reads batches from Kafka, inserts into click_events table
# Materialised view aggregates: clicks_by_day, clicks_by_country

Circuit breaker on Redis with DB fallback

from circuitbreaker import circuit, CircuitBreakerOpen

@circuit(failure_threshold=5, recovery_timeout=30)
async def cache_get(key: str) -> str | None:
    return await redis.get(key)

async def resolve_url(short_code: str) -> str:
    long_url = None

    try:
        long_url = await cache_get(f"url:{short_code}")
    except CircuitBreakerOpen:
        # Redis is known-failing, go straight to DB
        # Alert fires: this is a degraded but operational state
        pass
    except Exception:
        # Transient Redis error, circuit will count this failure
        pass

    if long_url is None:
        row = await db.fetchrow(
            "SELECT long_url FROM urls WHERE short_code = $1 AND "
            "(expires_at IS NULL OR expires_at > NOW())",
            short_code,
        )
        if row is None:
            raise HTTPException(status_code=404)
        long_url = row["long_url"]

        # Attempt to repopulate cache, but do not fail if Redis is down
        try:
            await redis.setex(f"url:{short_code}", 3600, long_url)
        except Exception:
            pass

    return long_url