System requirements

Functional:

• Users should be able to input any URL upto (lets say) 1000 characters. 1000 is a bit arbitrary, but we would want to set some upper bound, and get returned a shortened URL format.

Non-Functional:

• Low latency, should get a shortened URL within 1 second

Capacity estimation

• 10,000 concurrent requests

API design

POST /shorten API, takes in a URL and returns a response with a valid shortened URL that redirects to the inputted URL

Database design

1 DB to store URL and associated alias

High-level design

Client -> Load Balancer -> CDN (cache commonly inputted URL aliases) -> Server (generate the alias) -> DB (store the URL and alias)

Request flows

Client POSTS to /shorten with the URL, goes through maybe an API gateway which will send to CDN (probably redis) if cached, otherwise send through load balancer to server which generates the shortened URL, saves to DB (would it get cached here? is it like recency cache or popular cache, unsure how that works) and returns response to user

Detailed component design

• the server would likely be the bottleneck first, if it is gettign lots of requests then vertical scaling could do well at first (since the busines logic is not super complex), once that is exhausted then horizontal scaling with load balacner (AWS has some auto scaling thing)
• server could also be replaced maybe with aws lambda function to leverage against aws auto scaling
• the cache for common URL would probably be redis like i said earlier, but im unsure what is decided that gets cached. at the very least I think cache on edge server closer to user for recent and top K URLs.

Trade offs/Tech choices

• CAP theorem, consistency is not that important for this system, so prioritisiing availability through scaling to ensure handling concurrent loads is the best trade off.

Failure scenarios/bottlenecks

• Hot partitioning on edge cache
• concurrent requests (handled by scaling though)

Future improvements

• Add indexing to the cache DB (if supported) to handle large read volumes (since cache is mostly read)