System requirements

Functional:

• given a url, return a short url with fixed size of unique alphanumeric id.
• when accessed short URL it should route to original URL.
• Analytics of the URL, like usage count of each URL, when was it used last time etc.

Non-Functional:

• should handle high traffic
• should be always available
• low latency

Capacity estimation

Assuming 100 million total users,

and 50M daily users.

Each generates 10 short URLs.

one row in DB size: 180 bytes => 0.18 kb

short URL - 32 bytes

long URL - 100 bytes

date - 40 bytes

user Id - 8 bytes

daily 50M users => 50 * 10^5 * 10 * 180 => 9 * 10^8 bytes

annually => 9 * 10^8 * 365 bytes minimum DB size.

bandwidth required - each user takes 10 kb/s

daily 50M - 10 * 10^3 * 50 * 10^5 b/s

at peak load = 10^9 kb/s of bandwidth is required.

API design

POST: /createShortUrl, data: {"longUrl": "http://thelongurl.com"}

GET: /{uniqueShortId}

DELETE: /removeOldUrl

PATCH: /updateShortUrl/{uniqueShortId}, data: {"longUrl": "http://thelongurl2.com"}

GET: /health

GET: /stats/{uniqueShortId}

Database design

URL_TABLE

• short_url varchar(32)
• long_url varchar(100)
• creation_date date
• user_id varchar(8)
• long_url_hashcode

URL_STATS

• short_url varchar(32)
• user_id varchar(8)
• access_date date
• access_count number

USER_TABLE

• username
• password
• user_id
• last_login_date

High-level design

• User will login to system using username and passwd/OTP
• The Users will send request to System, load-balancer will sit in front to handle and route request to multiple pods of API server.
• API server will then store the generated short url to cache and DB
• To route short URL to original URL, API server will check for the entry in cache if miss then call DB fetch the data save it in cache and then route to its original URL
• Cache entry will have TTL of 1 year for eviction or LFU.

Request flows

User logins using username and password -> requests a short URL giving an original long URL -> system checks if data exists, if not creates short url saves it in cache and DB -> system returns short URL to user -> user hits short URL -> system checks if corresponding short URL exists if yes checks the cache for original URL if not found fetches it from DB, stores it in cache -> redirects user to original URL.

Detailed component design

Dig deeper into 2-3 components and explain in detail how they work. For example, how well does each component scale? Any relevant algorithm or data structure you like to use for a component? Also you could draw a diagram using the diagramming tool to enhance your design...

Trade offs/Tech choices

Explain any trade offs you have made and why you made certain tech choices...

Failure scenarios/bottlenecks

Try to discuss as many failure scenarios/bottlenecks as possible.

Future improvements

What are some future improvements you would make? How would you mitigate the failure scenario(s) you described above?