📅 February 02, 2026
⏱ 10 min read
Web & Networking

How to Create a URL Shortener With Redirects

A guide on building a URL shortening service, covering technology choices, │ database design, core logic for code generation and redirection, and deployment.

⭐ Intermediate

Creating a URL shortener with redirects involves several key components and steps. Here's a general outline of how you can approach it:

1. Choose Your Technology Stack

  • Backend Language/Framework: You'll need a server-side language and framework to handle requests, generate short codes, and interact with a database. Popular choices include Python (Flask, Django), Node.js (Express), Ruby (Rails), Go, or PHP (Laravel).
  • Database: A database is essential to store the mapping between short codes and original URLs. Options include PostgreSQL, MySQL, MongoDB, or even Redis for very high-performance, temporary short links.
  • Frontend (Optional but Recommended): For a user-friendly interface, you might use HTML, CSS, and JavaScript (with frameworks like React, Vue, or Angular) to allow users to input long URLs and see their generated short URLs.

2. Database Schema Design

You'll need a table (or collection) to store your URL mappings. A basic schema might include: * id: Primary key (auto-incrementing integer or UUID). * short_code: A unique, short string (e.g., "abcde") that will be part of your short URL. This should be indexed for fast lookups. * original_url: The full, long URL that the short code redirects to. * created_at: Timestamp of when the short URL was created. * clicks (Optional): A counter for how many times the short URL has been accessed.

3. Core Backend Logic

  • Short Code Generation:

    • When a user submits a long URL, your backend needs to generate a unique short_code.
    • This can be done by:
      • Random String Generation: Generate a random string of a fixed length (e.g., 6-8 characters) using alphanumeric characters. You'll need to check if this code already exists in your database and regenerate if it does to ensure uniqueness.
      • Hashing: Hash the original URL or a combination of the URL and a timestamp, then take a portion of the hash. This can be more deterministic but still requires uniqueness checks.
      • Base62 Encoding: If you're using an auto-incrementing id in your database, you can convert that integer ID to a base62 string (0-9, a-z, A-Z). This guarantees uniqueness and is very efficient.

  • Storing the Mapping:

    • Once a unique short_code is generated, store the short_code and original_url in your database.

  • Redirection Handling:

    • When a user accesses a short URL (e.g., yourshortener.com/abcde), your server needs to:
      1. Extract the short_code (abcde) from the URL path.
      2. Query your database to find the original_url associated with that short_code.
      3. If found, issue an HTTP 301 (Moved Permanently) or 302 (Found) redirect to the original_url. A 301 is generally preferred for permanent redirects as it's cached by browsers, reducing subsequent requests to your server.
      4. If not found, return a 404 Not Found error page.

4. API Endpoints (for backend)

  • POST /shorten:

    • Takes original_url in the request body.
    • Generates a short_code.
    • Stores the mapping.
    • Returns the full short URL (e.g., yourshortener.com/generated_code).

  • GET /:short_code:

    • Takes short_code from the URL path.
    • Looks up original_url.
    • Performs the redirect.

5. Frontend (if applicable)

  • A simple web page with an input field for the long URL and a button to submit.
  • Display the generated short URL to the user.

6. Deployment

  • You'll need a domain name (e.g., myurl.short).
  • Host your backend application on a server (e.g., AWS, Google Cloud, Heroku, Vercel).
  • Configure your web server (e.g., Nginx, Apache) to route requests to your backend application and handle the domain.

Example Flow:

  1. User visits yourshortener.com.
  2. User enters https://www.example.com/very/long/path/to/a/resource and clicks "Shorten".
  3. Frontend sends a POST request to yourshortener.com/shorten with the long URL.
  4. Backend generates a unique short_code like XyZ12a.
  5. Backend stores XyZ12a -> https://www.example.com/very/long/path/to/a/resource in the database.
  6. Backend responds with yourshortener.com/XyZ12a.
  7. User shares yourshortener.com/XyZ12a.
  8. Another user clicks yourshortener.com/XyZ12a.
  9. Their browser sends a GET request to yourshortener.com/XyZ12a.
  10. Backend looks up XyZ12a, finds the original URL.
  11. Backend sends an HTTP 301 redirect response to the user's browser, pointing to https://www.example.com/very/long/path/to/a/resource.
  12. The user's browser then navigates to the original long URL.