System requirements

Functional:

List functional requirements for the system (Ask the chat bot for hints if stuck.)...

1. Generate Short Urls for given long urls
2. Redirect to long url from given short url
3. 2 urls should not collide, i.e. 2 long urls cant have same short url

Non-Functional:

List non-functional requirements for the system...

1. Retriaval should be as fast as possible
2. Generate can be latent since one time process, but should be within limits

Capacity estimation

Estimate the scale of the system you are going to design...

API design

Define what APIs are expected from the system...

1. POST /long/{url} -> Response 8 length Short URL, Should be idempotent. Should return existing short url if already created
2. GET /short -> Response Long Url if present, else return 404

Database design

Defining the system data model early on will clarify how data will flow among different components of the system. Also you could draw an ER diagram using the diagramming tool to enhance your design...

Table

`shortUrl` -> (shortURL(PK), longURL(Unique))

High-level design

You should identify enough components that are needed to solve the actual problem from end to end. Also remember to draw a block diagram using the diagramming tool to augment your design. If you are unfamiliar with the tool, you can simply describe your design to the chat bot and ask it to generate a starter diagram for you to modify...

Request flows

Explain how the request flows from end to end in your high level design. Also you could draw a sequence diagram using the diagramming tool to enhance your explanation...

POST /long/{url} Request Flow

When a client submits a URL to be shortened via the POST /long/{url} endpoint, the service follows a specific sequence of operations to ensure that the URL is effectively stored and a short URL is returned. The sequence is as follows:

1. Client Request: The client initiates the process by sending a POST request with the long URL.
2. Existence Check: The URL Shortening Service checks the urlMap database table to see if the long URL already has an associated short URL.
   • If the URL exists: The service retrieves the corresponding short URL from the database and returns it to the client.
   • If the URL does not exist: The service generates a new 8-character alphanumeric string to be used as the short URL.
3. Storing the URL: The new pair (short URL and long URL) is stored in the urlMap table.
4. Response: The service responds to the client with either the existing or newly created short URL.

Below is the sequence diagram that illustrates these steps:

```mermaid

sequenceDiagram

  participant C as Client

  participant S as URL Shortening Service

  participant DB as Database (urlMap)

  C->>S: POST /long/{url}

  S->>DB: Check if long URL exists

  alt URL Exists

    DB->>S: Return existing short URL

    S->>C: Respond with short URL

  else URL Does Not Exist

    S->>S: Generate random 8-char short URL

    S->>DB: Store new entry (shortURL, longURL)

    DB->>S: Ack storage

    S->>C: Respond with new short URL

  end

```

GET /short Request Flow

When a client requests to retrieve the original long URL corresponding to a short URL via the GET /short endpoint, the service follows this sequence of operations:

1. Client Request: The client sends a GET request with the short URL.
2. Fetch from Database: The URL Shortening Service checks the urlMap database table for an entry matching the given short URL.
   • If the short URL exists: The database returns the associated long URL, and the service provides this long URL in its response to the client.
   • If the short URL does not exist: The database indicates a missing entry, prompting the service to respond with a 404 Not Found error.

Below is the sequence diagram illustrating these steps:

```mermaid

sequenceDiagram participant C as Client participant S as URL Shortening Service participant DB as Database (urlMap) C->>S: GET /short S->>DB: Fetch (shortURL, longURL) from urlMap alt Short URL Exists DB->>S: Return long URL S->>C: Respond with long URL else Short URL Does Not Exist DB->>S: Return not found S->>C: Respond with 404 Not Found end

```

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?