System requirements

Functional:

Create a short URL

Redirect to Long URL

Non-Functional:

High Availability

Low latency

Scalability

Data Consistency

Capacity estimation

DAU: 5x10^5

RPS: 5

API design

$basename/v1/short-url/

$basename/v1/bulk-short-urls/

Database design

short-URL

• id_url
• long_url
• short_url
• expiration_time

High-level design

The idea is to have two services:

1. Hashing service: transform the long url into a short-url and save into a database.
2. Retrieve or query the long url given the short -url.

The hashing service will be doing a transformation of ascii characters, the transformation can be just chaning the base ascii letters.

Request flows

Creation flow

1. The user request to shortening an URL.
2. Each request will be sent to a queue, in case that we have a lot of request at the same time. (kafka)
3. Then the hashing service takes each one of the requests encodes the long url into a short-url.
4. The short url and metadata are stored in the database

Query flow

1. The user requests the url for a tiny url.
2. The query service search this url in the cache.
3. If that url is not in the cache then it searches on the database.
4. Once the Query service has a response it is stored in the cache
5. The long-url is sent back to the client.

Cache will be done with redis, and the idea is to have enough replicas to serve the demands.

The database will be a noSQL or non relational database, since there are not complex relationships.

REST API design will consider a CRUD for short-url, and a bulk-url for cases where multiple urls might be required (like the one used on chatgpt, or linkedin).

Trade offs/Tech choices

Having a non-sql database might compromise consistency, however a usual use case doesn't require a lot of updates for shorturls.

Failure scenarios/bottlenecks

A point of failure might be having hashing collisions, in such case we would need to increase the basis used to transform the long URLs properly.

Future improvements

I would add another service to rebalance the hashing bassis, in this way we have less collisions.