System requirements

Functional:

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

1. Convert long URLs into shorter, unique URLs
2. Redirect users to the original URL when shortened URL is accessed
3. handle a high volume of request efficiently

Non-Functional:

List non-functional requirements for the system...

1. Scalability to handle millions or URLs
2. reliability - high availability and low latency
3. Fault tolerance and data durability

Capacity estimation

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

about 0.5 - 1 million processes per day since this would be a worldwide applicati

API design

Define what APIs are expected from the system...

• POST /short - enter in long url and return a short url
• GET /{short_url} - response - HTTP 301 redirect to long url

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...

CREATE TABLE urls (

id INT AUTO_INCREMENT PRIMARY KEY,

short_url VARCHAR(10) UNIQUE NOT NULL,

long_url TEXT NOT NULL,

created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP

);

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...

1. client sends url to load balancer
2. load balancer forwards request to backend server (Python)
3. backend server interacts with database and optionally cache
4. application server generates response with the short 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...

Storage vs. Performance

• Relational Databases (e.g., MySQL):
  • Pros: Strong consistency, structured schema.
  • Cons: May not scale well with high write/read volumes.
  • Trade-off: Reliability over performance.
• NoSQL Databases (e.g., DynamoDB):
  • Pros: Horizontal scalability, better performance under high loads.
  • Cons: Limited query capabilities, eventual consistency in some cases.
  • Trade-off: Scalability over advanced query capabilities.
• Caching (e.g., Redis):
  • Pros: Fast retrieval of popular URLs.
  • Cons: Increases memory usage, requires sync with database.
  • Trade-off: Memory cost for speed.

Scalability vs. Cost

• Horizontal Scaling (More Servers):
  • Pros: Distributes load, handles high traffic.
  • Cons: Higher infrastructure and management costs.
  • Trade-off: Cost for scalability and reliability.
• Vertical Scaling (Better Servers):
  • Pros: Easier to manage, fewer components.
  • Cons: Limited by hardware capacity.
  • Trade-off: Simplicity for scalability.

Failure scenarios/bottlenecks

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

Scenario: Database goes down or becomes unreachable.

• Impact: Shortened URLs cannot be stored or retrieved, leading to system downtime.
• Mitigation:
  • Use database replication (primary-replica setup).
  • Implement failover mechanisms to switch to a backup database.
  • Employ distributed databases (e.g., DynamoDB, CockroachDB) for fault tolerance.

Scenario: Data corruption or loss in the database.

• Impact: Loss of URL mappings, broken links.
• Mitigation:
  • Regular backups with automated restore procedures.
  • Enable transaction logs for recovery.

High Latency

• Scenario: Network latency causes delays in user requests.
  • Impact: Poor user experience.
  • Mitigation:
    • Use a Content Delivery Network (CDN) for redirection endpoints.
    • Implement edge caching for popular URLs.

Future improvements

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

Adding redis for caching for optimized performance