Requirements

Functional Requirements:

• Create a short URL for a given long URL.
• Return the long URL associated with a given short URL.

Non-Functional Requirements:

• Low latency: url creation < 100ms + fast redirect
• Consistency: generated urls should redirected original urls(at least during TTL we originally agreed)
• Reliable
• Scalable:

API Design

Basic entities:

user

provided_url

generated_url

Data model:

Table USERS:

user_id[pk]

pswd_hash

Table LINKS:

link_id

user_id

original_link(base32 encoded)

generated_link(using sha-256 and base32) [primary key]

created_at [sorting key]

Rest API:

1. POST /user/[id]/urls { url : {original_url} }
2. GET /user?url={tiny_url} -> redirect to original page

High-Level Design

Flow(generate url):

1. User sends request to encode url
2. request touches API Gateway
3. query process by application server
4. app server generates SHA-256 from original url and encode it using base 32 suitable for URL
5. generated value stored into DB as key-value pair {original url, generated url}
6. Api gateway sends back response with generated url

Flow(redirect):

1. request touches api gateway
2. goes to app server redirect service
3. service looks up for original url and sends response with redirect response to the user

Detailed Component Design

1. DB: since the data is well structured we can use SQL db(e.g. postgres). It also grants consistency of our data.
2. to grant scalability we should enable replication and sharding
3. To garanty low latency response we are going to use key-value cache(Redis) before lookup for the DB
4. for scalabilty we can introduce multiple app servers that will partition incoming requests
5. we are also going to use load balancer in front of our app servers
6. To garanty fault tolerance we also will have redundant LB, app servers and DB to hands outages.