DPTCloud
Back to articles
Technology Insight

Building a Self-Hosted Private URL Shortener: Deploying Open-Source Dub.sh on a Virtual Private Server (VPS)

May 30, 2026

Introduction: The Case for a Private URL Shortener

In the modern digital ecosystem, links are the primary connective tissue between brands and their audiences. While commercial link-shortening services like Bitly or Rebrandly offer convenience, they introduce significant trade-offs regarding data privacy, brand equity, and recurring operational costs. For enterprise organizations and privacy-conscious professionals, relying on third-party infrastructure means surrendering valuable click analytics and subjecting user data to external privacy policies.

Building a Private URL Shortener solves these challenges natively. By utilizing Dub.sh—an advanced, open-source link management platform—and deploying it on a Virtual Private Server (VPS), you retain absolute sovereignty over your data, enjoy advanced analytics without premium tier limitations, and can utilize your own custom branded domains. This technical guide provides a step-by-step blueprint for self-hosting Dub.sh on your own infrastructure.

Why Choose Dub.sh and Self-Hosting?

Dub.sh has quickly emerged as the gold standard for open-source link management, challenging proprietary SaaS solutions with a robust feature set and a highly polished user experience. When deployed on a private VPS, it offers several distinct advantages:

  • Complete Data Ownership: Every click, IP address, geolocation data point, and referral source remains securely stored within your private database, eliminating compliance risks associated with GDPR or CCPA.
  • Advanced Analytics: Access enterprise-grade tracking metrics, including device types, browser origins, geographic distribution, and detailed time-series data without artificial paywalls.
  • Custom Branded Domains: Elevate brand recognition and improve Click-Through Rates (CTR) by using your own short domains (e.g., go.yourbrand.com) instead of generic third-party domains.
  • Cost Efficiency: By leveraging a flat-rate VPS, you can process millions of redirects without encountering the tier-based pricing escalation typical of commercial platforms.
Strategic Insight: Branded short links can increase click-through rates by up to 34% compared to unbranded or generic short links, as they build immediate trust with the end user.

Prerequisites and System Requirements

Before initiating the deployment process, ensure your infrastructure meets the following baseline requirements:

1. Virtual Private Server (VPS) Specifications

  • Operating System: Ubuntu 22.04 LTS or Ubuntu 24.04 LTS (recommended for stability).
  • Hardware: Minimum 2 vCPUs, 2GB RAM, and 20GB SSD storage. Scale upward based on anticipated concurrent click traffic.

2. Network and Domain Assets

  • A registered domain name (e.g., yourbrand.link).
  • Access to your domain's DNS management console to configure A and CNAME records.

3. Software Dependencies

Dub.sh is built on a modern stack utilizing Next.js, Prisma, Tailwind CSS, and Upstash. For a self-hosted environment, we will utilize a containerized approach. Ensure the following are installed on your VPS:

  • Docker Engine (version 20.10+ or higher)
  • Docker Compose (version 2.0+ or higher)
  • Git

Step-by-Step Deployment Architecture

Step 1: Preparing the VPS Environment

First, establish an SSH connection to your VPS and update the system packages to their latest stable versions. Run the following commands in your terminal:

sudo apt update && sudo apt upgrade -y
sudo apt install git curl build-essential -y

Next, confirm that Docker and Docker Compose are installed and running correctly on the system:

docker --version
docker compose version

Step 2: Cloning the Repository and Environment Setup

Clone the official Dub.sh repository or the specialized self-hosting repository to your local directory. Navigate into the project folder to configure the environment variables:

git clone [https://github.com/dubinc/dub.git](https://github.com/dubinc/dub.git)
cd dub

Dub.sh requires several environment variables to handle database connections, authentication, and tokenization. Duplicate the example environment file to create your production configuration:

cp .env.example .env.production

Open the .env.production file with a text editor like Nano to populate your specific configurations, including your database credentials (PostgreSQL), Redis connection strings, and NextAuth secrets.

Step 3: Database and Storage Configuration

Dub.sh relies on a relational database (typically PostgreSQL) for core relational data and a fast key-value store (Redis) for caching redirect routes to achieve sub-millisecond latency. Within your docker-compose.yml file, define these services alongside the main application container:

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: dub_admin
      POSTGRES_PASSWORD: StrongSecurePassword
      POSTGRES_DB: dub_db
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    volumes:
      - redisdata:/data

  dub:
    image: dubinc/dub:latest
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://dub_admin:StrongSecurePassword@postgres:5432/dub_db
      - REDIS_URL=redis://redis:6373
    depends_on:
      - postgres
      - redis

Step 4: Configuring the Reverse Proxy and SSL Certificates

To ensure secure transmissions (HTTPS) and route traffic seamlessly from port 80/443 to your Docker container running on port 3000, a reverse proxy like Nginx or Caddy is essential. Below is a standard Nginx block configuration for your domain:

server {
    listen 80;
    server_name go.yourbrand.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name go.yourbrand.com;

    ssl_certificate /etc/letsencrypt/live/[go.yourbrand.com/fullchain.pem](https://go.yourbrand.com/fullchain.pem);
    ssl_certificate_key /etc/letsencrypt/live/[go.yourbrand.com/privkey.pem](https://go.yourbrand.com/privkey.pem);

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Utilize Certbot to acquire free, automated SSL certificates via Let's Encrypt to enforce strict transport security across all shortened links.

Optimizing Production Performance

Once deployed, fine-tuning your VPS ensures that link redirections occur instantaneously, preserving a seamless user experience. Implement the following optimizations:

1. Cache Aggression

Ensure that Redis is properly configured with a maxmemory-policy volatile-lru setting. This ensures that frequently accessed short links remain entirely in memory, minimizing database queries and dropping redirection times to single-digit milliseconds.

2. Connection Pooling

For high-traffic applications, utilize a database connection pooler like PgBouncer. This prevents the Next.js application from exhausting available PostgreSQL connection slots during viral traffic spikes.

Conclusion and Next Steps

By transitioning from commercial software to a self-hosted Dub.sh instance on a private VPS, you unlock enterprise link-management features while maintaining uncompromising control over corporate data assets and operational budgets. You are no longer subject to the arbitrary tracking limits, branding restrictions, or data retention policies of third-party vendors.

With your infrastructure fully operational, your next steps should include onboarding your marketing teams, configuring webhooks to pipe analytics into your internal data warehouses, and establishing automated daily backups for your PostgreSQL volumes to safeguard your redirect history.

Building a Self-Hosted Private URL Shortener: Deploying Open-Source Dub.sh on a Virtual Private Server (VPS) | DPTCloud