How to Install Coolify on a VPS (Step-by-Step Guide for 2026)

Coolify is an open-source, self-hosted platform-as-a-service that gives you the deployment experience of Vercel, Netlify, or Heroku — on infrastructure you actually control. Instead of paying per-seat fees, bandwidth overages, and management premiums, you install Coolify on your own VPS and deploy unlimited applications, databases, and services at a fixed monthly cost.

This guide walks you through the complete process: from provisioning a server to deploying your first application. By the end, you’ll have a production-ready Coolify instance running on high-availability infrastructure with automatic SSL, Git-based deployments, and a clean web dashboard for managing everything.

While Coolify offers a managed cloud option ($5/month management fee on top of your server costs), self-hosting eliminates that recurring fee entirely. And since Coolify includes an auto-update mechanism, you get the same software updates without paying for the management layer. The only requirement is a VPS with SSH access — and about 15 minutes of your time.

Server Requirements

Coolify runs on Docker and manages all its dependencies through its installation script. Here are the hardware requirements:

Why dedicated resources matter: Coolify uses Nixpacks to build Docker images from your source code. These builds are CPU-intensive — compiling Node.js applications, building Go binaries, or processing Python dependencies all spike CPU usage significantly. On shared infrastructure, other tenants competing for the same physical CPU cores can turn a 30-second build into a 5-minute wait. A Dedicated VPS with guaranteed CPU cores eliminates this noisy-neighbor problem entirely.

For development and evaluation, a Cloud VPS starting at 2 vCPU and 4 GB RAM works well. For production deployments where build speed and runtime consistency matter, step up to a Dedicated VPS with 4 dedicated cores and 8 GB RAM.

Step 1: Provision Your Server

Start by provisioning a VPS from the MassiveGRID Cloud VPS or Dedicated VPS configurator. Here’s what to select:

Choose your datacenter location

MassiveGRID operates four global datacenters. Choose the one closest to your primary user base:

• New York City (NYC) — Best for US East Coast and North American audiences
• London — Best for UK and Western European audiences
• Frankfurt — Best for Central European audiences and GDPR-compliant EU hosting
• Singapore — Best for Southeast Asian and APAC audiences

Select your OS template

Choose Ubuntu 24.04 LTS as your operating system. It’s the most widely tested configuration for Coolify and has long-term support through 2029.

Configure SSH access

During provisioning, add your SSH public key. If you don’t have one yet, generate it on your local machine:

ssh-keygen -t ed25519 -C "your-email@example.com"

Copy your public key and paste it into the SSH key field during server creation:

cat ~/.ssh/id_ed25519.pub

Why MassiveGRID’s infrastructure matters here

Unlike commodity VPS providers, MassiveGRID servers run on Proxmox HA clusters with Ceph distributed storage. This means your Coolify server’s storage is replicated across three separate physical disks (3x replication). If a disk fails, your data — Coolify’s internal database, your application code, your Docker volumes — remains intact on the surviving copies. On a standard VPS, a disk failure means data loss. On MassiveGRID, it means an automatic, transparent recovery.

Step 2: Initial Server Hardening

Once your server is provisioned, SSH in and harden it before installing Coolify.

Connect to your server

ssh root@your-server-ip

Update system packages

apt update && apt upgrade -y

Create a non-root user with sudo access

adduser deploy
usermod -aG sudo deploy

Copy SSH keys to the new user

mkdir -p /home/deploy/.ssh
cp /root/.ssh/authorized_keys /home/deploy/.ssh/
chown -R deploy:deploy /home/deploy/.ssh
chmod 700 /home/deploy/.ssh
chmod 600 /home/deploy/.ssh/authorized_keys

Configure UFW firewall

Coolify requires the following ports:

ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 8000/tcp
ufw allow 6001/tcp
ufw allow 6002/tcp
ufw enable

Disable password authentication

Edit the SSH configuration to enforce key-based authentication only:

sudo nano /etc/ssh/sshd_config

Set the following values:

PasswordAuthentication no
PubkeyAuthentication yes
PermitRootLogin prohibit-password

Restart the SSH service:

sudo systemctl restart sshd

Note: Coolify’s installer handles Docker installation automatically. Do not pre-install Docker — the Coolify script manages the exact versions and configuration it needs.

Step 3: Install Coolify

With your server hardened, install Coolify using the official one-liner. You can run this as root or with sudo:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

The installation script performs the following steps automatically:

• Installs Docker Engine and Docker Compose
• Creates the Coolify directory structure at /data/coolify/
• Pulls the Coolify Docker images
• Sets up the Traefik reverse proxy for automatic SSL and routing
• Configures an internal PostgreSQL database for Coolify’s metadata
• Starts the Coolify dashboard on port 8000
• Launches the Sentinel monitoring agent

The installation typically takes 2–5 minutes depending on your server’s internet connection speed. You’ll see output showing each component being pulled and started. When it finishes, you’ll see a message confirming that Coolify is running.

Current version note: As of February 2026, Coolify v4 is the current stable release with regular updates pushed through the auto-update mechanism.

Step 4: Access the Dashboard and Create Your Admin Account

Open your browser and navigate to:

http://your-server-ip:8000

You’ll see Coolify’s registration screen. Create your admin account by entering:

• Your name
• Email address
• A strong password

After registration, Coolify walks you through an onboarding wizard:

1. Server type: Select “localhost” for a single-server setup (your applications run on the same server as Coolify). For multi-server setups, see our multi-server Coolify guide.
2. Project creation: Coolify creates a default project to organize your deployments.
3. SSH key verification: Coolify verifies it can connect to the local Docker daemon.

Once onboarding completes, you’re in the Coolify dashboard — a clean, modern interface for managing all your deployments.

Security tip: After creating your admin account, disable public registration in Settings → Configuration to prevent unauthorized users from creating accounts on your instance.

Step 5: Configure Your Domain

Running Coolify on an IP address works for testing, but production use requires a proper domain with SSL. Here’s how to set it up:

Configure DNS

In your domain registrar’s DNS settings, create the following records:

A    coolify.yourdomain.com    → your-server-ip
A    *.coolify.yourdomain.com  → your-server-ip

The wildcard record (*) enables automatic subdomain routing for your deployed applications and preview deployments.

Update Coolify’s instance domain

In the Coolify dashboard, navigate to Settings → Configuration and update the instance FQDN to https://coolify.yourdomain.com. Coolify will automatically provision an SSL certificate through Let’s Encrypt via its built-in Traefik reverse proxy.

Verify SSL

After updating the domain, navigate to https://coolify.yourdomain.com in your browser. You should see the Coolify dashboard loading over HTTPS with a valid SSL certificate. Traefik handles certificate renewal automatically — no cron jobs or manual intervention required.

Step 6: Deploy Your First Application

With Coolify configured and your domain working, let’s deploy your first application.

Connect your Git provider

Navigate to Sources in the sidebar and connect your GitHub account. Coolify supports GitHub, GitLab, Bitbucket, and manual Git repositories. For GitHub, Coolify creates a GitHub App for secure repository access.

Create a new resource

1. Click + New Resource from your project
2. Select Application
3. Choose your Git source and select the repository
4. Select the branch to deploy (typically main)

Automatic build detection

Coolify uses Nixpacks to automatically detect your application’s framework and build a Docker image. It supports Node.js, Python, Go, Ruby, PHP, Rust, Java, and many more. No Dockerfile required — though you can provide one for custom builds.

Configure and deploy

1. Set your application’s domain (e.g., myapp.yourdomain.com)
2. Add any required environment variables
3. Click Deploy

Coolify builds your application, creates a Docker container, configures Traefik routing, provisions an SSL certificate, and makes your application live. The entire process typically takes 1–3 minutes for a standard Node.js or Next.js application.

What to Do Next

You now have a fully functional Coolify instance capable of deploying and managing applications, databases, and services. Here are the logical next steps:

• Deploy a Next.js application — The most common framework deployed on Coolify. Our guide covers Nixpacks optimization, environment variables, preview deployments, and performance tuning.
• Plan resources for multiple applications — Before deploying your second, third, or tenth application, understand how much CPU, RAM, and storage each workload needs. Includes concrete sizing tables.
• Set up a backup strategy — Protect your Coolify configuration, application databases, and Docker volumes with automated backups to S3-compatible storage.
• Harden your server for production — Go beyond the basics with fail2ban, Docker security best practices, and a regular audit checklist.

For a deeper comparison of self-hosted PaaS options, see our Dokploy vs Coolify vs CapRover analysis, which covers resource consumption, feature sets, and multi-server scaling across all three platforms.

Self-hosting your deployment platform is one of the highest-leverage infrastructure decisions you can make. Coolify provides the developer experience of managed platforms, and MassiveGRID’s HA infrastructure provides the reliability that makes self-hosting production-grade. The combination gives you full control without the compromises that traditionally came with running your own servers.

For an alternative self-hosted PaaS with a lighter resource footprint, explore Dokploy on MassiveGRID.