Requirements

Let's revisit the classic URL Shortener problem. It seems simple on the surface, but crafting a robust and scalable design requires careful consideration of various factors. Imagine you're building a service like bit.ly or tinyurl.com. Our goal is to take a long URL and convert it into a shorter, more manageable URL. When a user accesses the shortened URL, they should be seamlessly redirected to the original URL. This problem is more than just a simple string manipulation task. It involves choosing the right data structures, handling collisions, and ensuring the system can handle a large volume of requests efficiently and safely in a concurrent environment. The heart of the system is the mapping between short URLs and original URLs. This mapping needs to be persistent (at least within the context of an interview), highly performant, and thread-safe. We need to consider strategies for generating short URLs (e.g., base-62 encoding), resolving them quickly, and dealing with edge cases like invalid URLs. # Requirements ## Functional Requirements 1. **URL Shortening:** * Given a long URL, the system must generate a unique short URL. * The system must support customizable short URLs (ability to specify a preferred short URL). If the specified URL is already taken, the system should return an error. * The system must validate that the input URL is a valid URL format. 2. **URL Redirection:** * When a user accesses a short URL, the system must redirect them to the corresponding original URL. * The system should track the number of times a short URL has been accessed (click count). * The system should handle cases where a short URL is invalid or has expired, redirecting to a default page (e.g., error page). 3. **URL Management:** * The system must allow users to delete existing short URLs. * The system must allow users to update the target URL of an existing short URL. * The system must provide an API to retrieve the original URL, creation date, and access count for a given short URL. 4. **Concurrency & Thread Safety** * Multiple threads should be able to call the `shortenUrl()` and `redirectUrl()` functions concurrently without data corruption. ## Non-Functional Requirements 1. **Performance:** * The system should be able to handle a large number of URL shortening and redirection requests with minimal latency. * Redirection should be fast, aiming for near-instantaneous redirection times. 2. **Scalability:** * The system should be designed to handle a growing number of URLs and users. * Consider how the data storage mechanism could be scaled horizontally. 3. **Availability:** * The system should be highly available, with minimal downtime. (While full HA isn't in scope for the code, the design should avoid single points of failure within the *code*.) 4. **Security:** * The system should prevent malicious users from creating short URLs that redirect to harmful websites. A simple validation on URL is enough here. * The system should prevent URL spoofing or other security vulnerabilities. 5. **Maintainability:** * The code should be well-structured, modular, and easy to understand and maintain. * The design should be extensible to support new features and functionality in the future. 6. **Thread Safety:** * The URL mappings must be stored and accessed in a thread-safe manner to prevent data corruption in a concurrent environment. Pay close attention to how you synchronize access to shared data structures. 7. **Extensibility:** * The design should be open to extension. For example, adding a new URL generation strategy (e.g., using UUIDs instead of base-62 encoding), supporting different redirection strategies (e.g., 301 vs. 302 redirects), or integrating with other services. 8. **Testability:** * The code should be designed to be easily testable, with well-defined interfaces and clear separation of concerns. Focus on unit testing the core logic of the URL shortening and redirection functionality. ## Core Entities 1. **`URLShortener`**: The main class responsible for shortening and redirecting URLs. It orchestrates the interactions between other components. 2. **`URLMapping`**: Represents a single mapping between a short URL and its original URL. It should include the original URL, short URL, creation timestamp, expiration timestamp (optional), and click count. 3. **`ShortURLGenerator`**: An interface (or abstract class) responsible for generating unique short URLs. Different implementations can be used for different URL generation strategies (e.g., base-62 encoding, UUID). This promotes extensibility through the Strategy pattern. 4. **`URLStorage`**: An interface defining how URL mappings are stored and retrieved. Implementations could include in-memory storage (for simplicity), file-based storage, or a database connection. The `URLStorage` implementation must be thread-safe. 5. **`Validator`**: Interface to validate URL format.

Design a URL Shortener with Collision Handling and Analytics

Requirements

Interview Simulation

Functional Requirements

💡 Interview Tip

Non-Functional Requirements

Core Entity Identification

Premium Content