Requirements

Functional Requirements:

• Users can input a long URL that gets redirected to a short URL
• Users can login, but we also allow visitors
• Users that are logged in can see their SAVED shortened URLs

Non-Functional Requirements:

• High availability
• low redirect latency
• horizontal scaling: no single bottleneck, we add multiple instances
• durability: created mapping cannot be lost
• security

Capacity Estimation

• For 100M URLs/month
• High Read to Write Ration (100:1)
• 100M URLs × 500 bytes × 12 months × 5 years ≈ 3 TB storage
• Cache the hot 20% → ~600 GB

API Design (RPC)

• GET: Get the shortened URL and the long URL if there is one
• POST (for visitors): Send form, get shortened URL back
• POST (logged in users): Same behavior
• POST: Update the URL if changes
• POST: Deletion of URL

High-Level Design

• Clients
• Cache
• Load Balancer: Routes and distributes load before backend
• Database: Store short to long mapping
• Server: has shortening service and redirect service. Shortening service takes a url request and write into db, building a mapping. Redirect service takes a request + reads mapping reroutes traffic

Database Design

Relational Database: Postgres.

Reason: Mapping Users and their URLs

• Tables: Users; URLs
• Users table: id, email, passwordhash,
• URL table: id, long url, short url = sharding key, index on short, fk to user_id, created_at
• no duplication
• Creation = strong consistency: a returned short code must be durable and never duplicated.
• Redirects = eventual consistency OK: replica lag might cause a brief transient 404, but never corruption — because you never read stale data that's wrong, it just might not be there yet.

Detailed Component Design

• Cache: Redis (In-Memory DB), fast retrieval; When cache miss: fetch mapping from DB and serve redirect + backfill cache
• How can we never get collision in two creates: random Base62 encoding + retry
• How can we make the ids unguessable: Encoding from above
• Even spread + hotspot mitigation: Even spread solvable via sharding and replication. If hotspot, hit cache. If cache miss, hit shardened url.