System requirements

Functional:

• Users can create a static short URL which points to their own longer URL
• Users who visit an existing short URL will be redirected to the corresponding longer URL
• Users should be able to create expiring URLs
• Users should be able to create their own shortURL

Non-Functional:

Availability:

• Visiting URLs should be highly available, with creation of URLs also available but maybe a lower priority.

Consistency:

• New URLs/writes should be strongly consistent: you should not be able to create duplicate short URLs
• URL reads should be eventually consistent

Performance:

• avg URL redirects should be a couple of ms (network latency)
• p99 URL creation should be a couple of seconds max

Scalability:

• 100s of wpm,
• 1000s of rpm

Durability:

• Once created, a long URL should persist until expiration

Security:

• Ignoring authN/Z for URL creation for now.
• Reading redirects is open to public

Capacity estimation

If we build this in the cloud, we can scale to need.

API design

• createURL:
  • destination URL
  • optional custom URL
  • optional expiration time, but default expiration set to some value

readURL will be done with DNS

Database design

Pretty much just columns for each of the parameters: short, long, expiration date. Databases like Dynamo and Spanner can do expiration for us.

High-level design

The authoritative mapping of short URLs to longURLs will be in a scalable database like DynamoDB or GCS Spanner.

Reads will be done via a load balanced DNS server. Reads are trivially cache-able, so DNS servers will have a cache

Writes go to a write webserver fleet, with autoscaling

Request flows

read short url:

DNS request -> DNS server -> cache

OR

DNS request -> DNS server -> database (eventually consistent read)

write short url:

createURL -> creationService -> write to DB -> creationService -> user

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?