DPTCloud
Back to articles
Technology Insight

Self-Hosting Daytona on a VPS: Building Your Own Cloud Development Environment (CDE) to Replace Gitpod

June 6, 2026

Introduction: The Shift Toward Cloud Development Environments (CDEs)

In the modern software development lifecycle, local environments are rapidly becoming a bottleneck. The classic phrase "it works on my machine" still echoes across engineering teams, signaling lost productivity, configuration drift, and security vulnerabilities. Cloud Development Environments (CDEs) have emerged as the definitive solution to these challenges, providing standardized, pre-configured development workspaces in the cloud.

While platforms like Gitpod and GitHub Codespaces popularized this paradigm, relying entirely on third-party SaaS providers introduces complex challenges for enterprises. Licensing costs can escalate quickly, and more importantly, data privacy regulations often prohibit hosting proprietary source code on external cloud infrastructure. This is where Daytona enters the frame. Daytona is an open-source, highly versatile CDE orchestrator that allows organizations to regain control. By deploying Daytona on your own Virtual Private Server (VPS), you can build a self-hosted CDE platform that matches the user experience of Gitpod while retaining absolute data sovereignty and reducing infrastructure overhead.

Why Choose Daytona Over Gitpod?

Before diving into the technical deployment, it is essential to understand the strategic advantages of transitioning from a SaaS CDE like Gitpod to a self-hosted Daytona architecture on a VPS:

  • Absolute Data Sovereignty: Your source code, environment variables, and proprietary algorithms never leave your private network. This is critical for compliance with GDPR, HIPAA, or strict internal corporate policies.
  • Cost Predictability and Efficiency: Instead of paying per-user, per-hour SaaS fees, you pay a flat rate for your VPS instance. As your team scales, you can optimize resource utilization by adjusting the underlying hardware.
  • Infrastructure Agnosticism: While Gitpod requires complex Kubernetes setups for self-hosting, Daytona is lightweight. It can run seamlessly on a single Docker-enabled VPS, yet scales effortlessly to multi-node clusters if required.
  • Deep Customization: Daytona supports multiple providers and container engines, allowing engineers to mimic production environments with precision, whether they rely on Docker, SSH, or specialized cloud providers.

Prerequisites and Infrastructure Planning

To ensure a resilient and high-performing CDE platform, your VPS must meet specific baseline requirements. Because Daytona compiles code and spins up separate workspace containers, allocating sufficient resources is paramount.

Recommended VPS Specifications

  • CPU: Minimum 4 vCPUs (Compute-optimized instances are highly recommended).
  • RAM: 8 GB minimum (16 GB or higher preferred to handle multiple concurrent workspaces).
  • Storage: 50 GB+ NVMe SSD (Workspace caching and Docker images consume significant disk space).
  • OS: Ubuntu 22.04 LTS or Ubuntu 24.04 LTS (Clean installation).
  • Network: A static IPv4 address and a fully qualified domain name (FQDN) pointed to your VPS IP via A records (e.g., daytona.yourcompany.com).

Step-by-Step Deployment Guide

Step 1: Preparing the VPS Environment

First, establish an SSH connection to your VPS and update the system packages to their latest versions to ensure security and stability:

sudo apt update && sudo apt upgrade -y

Next, install essential dependencies, including Curl, Git, and Docker. Docker acts as the default container engine where Daytona will isolate and execute your development workspaces:

sudo apt install curl git apt-transport-https ca-certificates gnupg lsb-release -y

# Install Docker
curl -fsSL [https://get.docker.com](https://get.docker.com) -o get-docker.sh
sudo sh get-docker.sh

# Enable and start Docker service
sudo systemctl enable docker
sudo systemctl start docker

Step 2: Installing the Daytona Server

Daytona simplifies the installation process through a unified binary setup script. Run the following command to download and install the latest version of the Daytona CLI and Server daemon onto your VPS:

curl -sfL [https://download.daytona.io/daytona/install.sh](https://download.daytona.io/daytona/install.sh) | sudo bash

Once the installation script completes, verify that the binary is accessible by checking the version:

daytona --version

Step 3: Initializing and Configuring Daytona

With the binary installed, you can initialize the Daytona Server. It is highly recommended to run Daytona as a system service to ensure it automatically restarts if the VPS reboots.

sudo daytona server configure

During configuration, you will be prompted to define the server API URL, target ports, and storage backends. Ensure that you input your domain name (e.g., [https://daytona.yourcompany.com](https://daytona.yourcompany.com)) to allow secure external communication. After configuring, start the server application daemon:

sudo systemctl start daytona
sudo systemctl enable daytona

Step 4: Setting Up the Reverse Proxy and SSL (Nginx & Let's Encrypt)

To secure communications between your local machine, your browser, and the Daytona server, you must implement a reverse proxy with an SSL certificate. Install Nginx:

sudo apt install nginx -y

Create a new Nginx configuration block for Daytona:

sudo nano /etc/nginx/sites-available/daytona

Insert the following configuration, ensuring you replace the placeholder domain with your actual FQDN:

server {
    listen 80;
    server_name daytona.yourcompany.com;

    location / {
        proxy_pass [http://127.0.0.1:3986](http://127.0.0.1:3986); # Default Daytona internal port
        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;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Link the configuration file to enable it, test Nginx for syntax errors, and reload the service:

sudo ln -s /etc/nginx/sites-available/daytona /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Secure the installation by obtaining a free Let's Encrypt SSL certificate via Certbot:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d daytona.yourcompany.com

Creating Your First Cloud Workspace

Now that your private Daytona server is operational and securely accessible, you can initialize workspaces directly from your terminal or the web user interface. Authenticate your local machine's CLI with your new server instance:

daytona target set -p [https://daytona.yourcompany.com](https://daytona.yourcompany.com)

To provision a fresh, isolated development environment from a public or private repository (such as GitHub, GitLab, or Bitbucket), run the creation command:

daytona create [https://github.com/your-organization/your-repo.git](https://github.com/your-organization/your-repo.git)

Daytona automatically reads the repository's configuration, provisions a secure Docker container on your VPS, clones the code, and sets up specified runtimes. You can seamlessly connect your local IDE (such as VS Code, Cursor, or JetBrains) to this remote environment with a single command:

daytona code
Security Best Practice: Always restrict access to the Daytona Server API port using standard firewall rules (UFW). Only allow traffic over ports 80 and 443, ensuring all internal communication passes securely through your reverse proxy.

Enterprise Considerations: Performance Optimization

Running a CDE platform requires proactive monitoring to maintain optimal performance for your engineering team:

  • Workspace Pruning: Implement cron jobs to remove inactive workspace containers and clear untagged Docker layers to conserve NVMe storage space.
  • Resource Constraints: Configure Docker daemon parameters to prevent a single runaway compilation task or memory leak within a workspace from destabilizing the entire VPS host.
  • Automated Backups: Ensure the ~/.config/daytona directories and configuration databases are regularly backed up to external, detached block storage or S3-compatible buckets.

Conclusion

Transitioning from Gitpod to a self-hosted Daytona solution on a VPS empowers your organization to leverage the immense productivity gains of Cloud Development Environments without sacrificing security, budget predictability, or flexibility. By taking control of your CDE platform, you future-proof your infrastructure and ensure your engineering teams can innovate rapidly within an environment you own entirely.