Handbooks / System Design Case Studies / Chapter 1

Design a URL Shortener

12 pages · ~18 min✓ Reviewed

Start here. Next up: Design a Rate Limiter.

System Design Case StudiesPage 1

Problem Statement, Scope and Requirements (URL Shortener)

1. Scope and Functional Needs

In scope: create short link, redirect, custom alias, expiry, click analytics

Out of scope: user auth UI
Out of scope: link previews
Out of scope: spam ML

Operation	Input	Output
Create	`POST` long URL, alias optional, TTL optional	short URL
Redirect	`GET` short code	redirect to the long URL

Default TTL when none is given: 5 years

2. Non-Functional Targets

Redirect latency: p99 under 50 ms
Read availability: 99.99% on redirects
Immutability: a created link never changes target
Reads matter more than writes: a slow or failing redirect breaks every link ever shared

3. Capacity Estimates

System Design Case StudiesPage 2

High-Level Architecture (URL Shortener)

1. Components

Component	Job	Scales by
Load balancer	Spreads requests, health-checks nodes	Add LB nodes
Stateless API servers	Validate, encode, look up, redirect	Add nodes
ID generator	Unique integer per new URL	Counter ranges or KGS
Cache (Redis)

System Design Case StudiesPage 3

Short Code Generation: Base62 and Length (URL Shortener)

1. Alphabet and Length

Base62 alphabet: 0-9, a-z, A-Z = 62 symbols per character
Avoid base64's + and /: URL-unsafe, they need escaping
Codes must be unique, short, and non-guessable if links are private

Length	Formula	Codes	Verdict

System Design Case StudiesPage 4

Code Strategies: Counter vs Hash vs Random (URL Shortener)

1. Hash and Counter

Hash: MD5 or SHA-256 of the long URL, keep the first 7 base62 chars
Stateless: any API server computes the same code for the same URL
Collisions grow past ~1M links (birthday bound on 7 chars)
Same long URL gives the same code, so it is dedup-friendly

On insert, check the DB for the code
On conflict, append a salt or counter to the URL and rehash
Cost: one extra read per write

System Design Case StudiesPage 5

Redirect Service: 301 vs 302 (URL Shortener)

1. GET /{code} Flow

GET /{code}

System Design Case StudiesPage 6

Custom Aliases and Link Expiry (URL Shortener)

1. Expiry Flow

GET /{code}

Lazy expiry: check expires_at on every read, return 410
No timer per link; an expired row costs nothing until it is read
Daily batch job deletes expired rows and recycles the keys
Batch is cleanup only; correctness comes from the read check

2. Data Model

System Design Case StudiesPage 7

Click Analytics Pipeline (URL Shortener)

1. Off the Redirect Path

Never write analytics on the redirect path
Redirect returns first, then publishes a click event to Kafka
Event: {code, ts, ip, user_agent, referrer}
Publish is asynchronous: the redirect never waits for Kafka

Redirect302 sent
Kafkaclick event
Consumersaggregate
ClickHousecolumn store

System Design Case StudiesPage 8

Read-Heavy Caching Layer (URL Shortener)

1. Cache-Aside Read Path

GET /{code}

Key is the short code, value is the long_url
On miss: read the DB, then SET with a TTL
Writes also populate the cache: a new link is hot at once
Target: 95%+ hit ratio, miss path under 10 ms DB read

bash

GET abc1234
SET abc1234 "https://example.com/long" EX 3600

hit returns the URL; on miss, fill with an EX TTL

System Design Case StudiesPage 9

Database Design and Sharding (URL Shortener)

1. Access Pattern

Only query: lookup by short_code returns long_url
No joins, no range scans, no secondary reads on the hot path
NoSQL (DynamoDB, Cassandra) and sharded SQL both fit
Writes: about 400/s at 10x peak; reads: about 40,000 QPS peak

2. Sharding and Sizing

Shard key = hash(short_code) placed on a consistent hashing ring
Hashing spreads load evenly: no range hot spots from sequential IDs

System Design Case StudiesPage 10

Scaling, Failures, Trade-offs and Interview Questions (URL Shortener)

1. Scale Path, Regions and Abuse

API autoscalestateless, ~10 nodes
Redis cluster3 shards, ~35 GB
Read replicasasync, lag under 1 s
CDNhot 301/302 targets
Shard last~6 shards, ~50% fill

Peak 40,000 QPS / 4,000 QPS per node = about 10 API nodes
Stateless nodes: add or remove freely, no sticky sessions
Sharding is last: ~3 TB in 5 years needs ~6 shards at ~50% fill (3 is the bare minimum)

System Design Case StudiesPage 11

URL Shortener Cheatsheet

Revision notes for the bit.ly-style URL Shortener: numbers, status codes, code generation, cache, analytics.

1. Estimates

Metric	Estimate
Writes	40/s avg, 400/s at 10x peak
Reads (100:1)	4,000 QPS avg, 40,000 peak
Storage	500 B x 100M x 12 x 5 yr = 3 TB

System Design Case StudiesPage 12

Check yourself

A counter hands out ID 3844 (that is 62 squared). With the alphabet 0-9, a-z, A-Z, what short code does base62 encoding produce? What does the next ID tell you about this scheme?

3844 % 62 = 0, then 62 % 62 = 0, then 1 % 62 = 1; reversed, the remainders give 100
Index 0 is '0' and index 1 is '1', so the code is 100, which is 1x62^2
The next ID, 3845, encodes to 101, so neighbouring codes are neighbouring links
Sequential base62 leaks creation order and volume, and anyone can guess other codes
If links are private, use a key service or random-looking codes instead

Spot the bug: a team serves every redirect as 301 with Cache-Control: max-age=31536000. Later they notice click counts fall short and an expired link still opens for some users. Why?

Estimate	Math	Result
Writes	100M / month	~40/s avg, ~400/s peak
Reads	100:1 read-to-write	10B/month, ~4,000 QPS avg, ~40,000 peak
Storage	500 B x 100M x 12 x 5 yrs	3 TB
Cache	20% of 350M daily = 70M x 500 B	~35 GB RAM

	Read service	Write service
Endpoint	`GET /{code}`	`POST /v1/urls`
Peak load	~40,000 QPS	~400 writes/s
Talks to	Redis, then read replicas	ID generator, primary DB
Autoscale on	QPS and p99 latency	CPU, small fleet

	301 Moved Permanently	302 Found (temporary)
Caching	Browsers and CDNs cache it	Not cached, every click hits you
Repeat clicks	Skip your server	Reach your server
Load	Lower	Higher
Analytics	Lose cached clicks	Full, every click
Change or expire target	Hard	Easy

Metric	Target
Redirect latency	track p50 and p99, p99 under 50 ms
Cache hit ratio	above 95%
4xx rate	watch 404 and 410 spikes (scanners, expiry)
Redirect QPS	about 4,000 avg, 40,000 peak

Column	Role
`short_code`	PK, unique index; holds alias or generated code
`long_url`	Target, never changes after create
`user_id`	Owner of the link
`created_at`	Creation time
`expires_at`	Nullable; null means default TTL

	Hash	Counter	KGS
Collisions	retry on conflict	none	none
Guessable	no	yes	no
Same URL, same code	yes	no	no
Extra cost	1 read per write	distributed counter	key service to run

Status	When
201	Created; body has `short_url`
409	`custom_alias` already taken
400	Alias breaks the rules or is reserved
410	Redirect hit an expired link

Estimate	Math	Result
Peak ingest	40,000 clicks/s x ~200 B	8 MB/s
Monthly raw	10B clicks x 200 B	~2 TB
Raw events	kept 30 days	then dropped
Rollups	per minute, country, device	kept forever

Item	Estimate
Daily redirects	350M
Hot share	20% = 70M keys
Record size	500 B
Cache size	70M x 500 B = 35 GB
Layout	one Redis cluster, 3 shards (~12 GB each)

Failure	Trigger	Fix
Cache stampede	Viral link key expires, thousands miss at once	Request coalescing or a lock: one request refills
Code scanning	Attacker hits random codes, every one misses	Negative cache 404s for 60 s: `SET nf:zz9Qx1 1 EX 60`

Plan	Result
Data over 5 years	3 TB (500 B x 100M/month x 60)
Node capacity	1 TB
3 shards x 1 TB	100% full, no headroom
6 shards x 1 TB	~50% fill, room to grow
6 shards x (1 primary + 2 replicas)	18 nodes

Decision	Option	Wins	Costs
Redirect	301	Browsers and CDN cache it; less load	Lost clicks; hard to undo
Redirect	302	Every click counted; can expire	Higher load
Code gen	Hash	Stateless, dedup-friendly	Collision retries
Code gen	Counter	No collisions	Guessable; needs coordinator
Code gen	KGS	Unique, random-looking	Extra service to run
Storage	Sharded SQL	Unique index, familiar	Manual sharding
Storage	NoSQL	Pure key-value fit, auto-shard	Weaker ad-hoc queries
New links	Strong	Fresh link never 404s	Reads hit primary
New links	Eventual	Replicas scale reads	Fresh link may 404 for under 1 s

Response	Meaning	Note
`302`	Temporary	Every click hits you: analytics, expiry
`301`	Permanent	Browsers/CDN cache it; clicks are lost
`404`	Unknown code	Negative-cache it
`410`	Expired	Gone, checked on read
`409`	Alias taken	On POST create

Design a URL Shortener

1. Scope and Functional Needs

2. Non-Functional Targets

3. Capacity Estimates

1. Components

1. Alphabet and Length

1. Hash and Counter

1. GET /{code} Flow

1. Expiry Flow

2. Data Model

1. Off the Redirect Path

1. Cache-Aside Read Path

1. Access Pattern

2. Sharding and Sizing

1. Scale Path, Regions and Abuse

1. Estimates

2. Write and Read Paths

3. Separate Read and Write Services

4. Stateless Servers Behind the LB

2. Encoding an ID

3. Guessability and Metrics

2. Key Service and Counter Ranges

3. Comparison

4. Mistakes

2. 301 vs 302

3. Pitfall and Metrics

3. Create API and Alias Rules

4. Failure: Concurrent Alias Claim

2. Volume and Retention

3. Stats API

4. Metrics

2. Sizing and Eviction

3. Failure Scenarios

4. Edge Cache

3. Replication and Failure

4. Metrics

2. Interview Questions

3. Trade-offs

2. Redirect

3. Code Generation

4. Cache and Analytics