URL Shortener

Use a stateless API, durable link mappings, cache-aside redirects, and asynchronous click processing. The diagram shows logical dependencies; production services may have multiple instances behind a load balancer.

6 components · 5 connections. One valid design among several; compare the reasoning, not just the shape.

1. Validate an absolute HTTP(S) destination and expiry. Generate an 8-character code using a secure random source. Insert the mapping with a unique code constraint; retry conflicts up to five times, then return a retryable error.
2. For redirects, look up the code in cache, then in the database on a miss. Return 404 if absent and 410 if expiresAt is in the past. Preserve expired records or tombstones for the documented retention period if 410 must remain distinguishable from 404.
3. Cache active records for min(defaultTTL, expiresAt − now). Recheck expiry even on cache hits. Return a 302 redirect so the service can continue checking expiry and collecting events on subsequent visits.
4. Enqueue a click event without waiting for analytics processing. Use bounded queue admission and a short timeout; if the analytics queue fails, still redirect and record a dropped-event metric under the stated best-effort analytics policy.
5. At 10,000 reads/s and an assumed 95% hit ratio, the database sees about 500 reads/s. At 100 creates/s and 500 bytes/record, new mappings consume about 4.32 GB/day before indexes, replicas and expiry. These are planning estimates, not measured limits.

POST /links { destination, expiresAt? } → 201 { code, shortUrl, expiresAt }
GET /:code → 302 Location: destination | 404 unknown | 410 expired
Link { code PRIMARY KEY, destination, createdAt, expiresAt nullable }
ClickEvent { eventId, code, occurredAt }

Core flow · illustrative pseudocode, not an executable implementation.

create(destination, expiresAt):
  validateHttpUrl(destination); validateExpiry(expiresAt)
  repeat up to 5 times:
    code = secureRandomBase62(8)
    if database.insertUnique(code, destination, expiresAt): return code
  throw RetryableCodeAllocationError

redirect(code, now):
  link = cache.get(code) or database.find(code)
  if link is absent: return 404
  if link.expiresAt != null and now >= link.expiresAt: return 410
  cacheBestEffort(link, ttlBoundedByExpiry(link, now))
  enqueueClickBestEffort(code, timeout=short, queue=bounded)
  return 302 with Location = link.destination

Use the exercise workload as a planning envelope. The daily volume assumes the stated write rate is sustained for 86,400 seconds and every write adds one record of the stated size; updates, deletions and sampling change retained growth. These are arithmetic estimates, not measured service capacity.

Daily write operations

100 writes/s × 86,400 s/day

8,640,000 writes/day

Raw write payload per day

100 writes/s × 500 B/write × 86,400 s/day ÷ 1,000,000,000

4.32 GB/day before indexes, replicas, compression and retention

Read request budget

10,000 reads/s with a target read p99 of 100 ms

Measure end-to-end tail latency, then allocate deadline budgets across the actual critical path. A p99 target is not a mean service time and cannot size concurrency by itself.

• Random codes avoid a central sequence allocator but require collision handling. Longer codes increase the available namespace.
• Cache failures need bounded fallback, admission control and request coalescing to avoid overwhelming the database.
• Best-effort click events can be lost. If loss is unacceptable, introduce durable event capture and explicitly revisit redirect availability and latency.
• Add create-rate limits, abuse reporting and destination policy checks. Any future server-side URL fetching requires separate SSRF protections.

Tests to validate the design

• Two concurrent inserts with the same generated code: one succeeds and the other retries.
• A cache hit at the exact expiry boundary returns 410, never a redirect.
• Unknown code returns 404; a retained expired mapping returns 410.
• A saturated analytics queue or cache outage does not cause unbounded waits or memory growth.