Your Own Vercel or Heroku on a VPS: Coolify vs Dokploy Tested

Coolify vs Dokploy comes down to this: both are free, open-source self-hosted PaaS tools that turn one VPS into your own Vercel or Heroku, with Git deploys, databases and automatic HTTPS. In our lab on identical 2 vCPU / 3 GB KVM machines, Coolify installed faster (140 seconds against 202), used about half the memory at idle (about 0.5 GB against 1.1 GB) and built our test app on a supported Node.js version without being asked. Dokploy has the simpler screens and builds on Docker Swarm, which makes it the easier route to several servers later. Either one swaps a per-seat monthly bill for a flat server price.

Key facts, checked on 9 October 2026:

• Coolify's latest release is v4.4.3 (8 October 2026), Apache 2.0 licensed, with 62,740 GitHub stars (GitHub). Its docs ask for at least 2 CPU cores, 2 GB of RAM and 10 GB of free disk (Coolify installation docs).
• Dokploy's latest release is v0.30.8 (29 September 2026), with 37,718 GitHub stars. Its code is Apache 2.0 except for folders named /proprietary (GitHub). Its docs ask for at least 2 GB of RAM and 30 GB of disk (Dokploy installation docs).
• Vercel Pro costs $20 a month per developer seat with $20 of usage credit and 1 TB of data transfer included (Vercel pricing).
• Render's Pro workspace is a flat $25 a month plus compute, and a 2 GB web service adds $25 (Render pricing).
• In our lab, Dokploy's own Node.js process held about 960 MB of RAM after 20 idle minutes, while Coolify's whole stack of five containers stayed near 500 MB.

What a self-hosted PaaS actually does

PaaS means "platform as a service": you hand over your code, and the platform builds it, runs it, gives it a web address and restarts it when it crashes. Heroku made the idea popular; Vercel, Netlify, Railway and Render sell it today, usually priced per user and per resource.

Coolify and Dokploy give you the same workflow on a server you rent. Both run everything as Docker containers (isolated packages of an app and its dependencies) behind Traefik, a reverse proxy that takes every request on ports 80 and 443, passes it to the right container and fetches free certificates from Let's Encrypt. You paste a Git URL into a web dashboard, press deploy and watch the build log, and databases such as PostgreSQL, MySQL and Redis are one click away. The server itself, its updates and its disk space stay your responsibility.

How we tested them

We ran both tools side by side on our Amsterdam test server on 9 October 2026. Each one got its own fresh Debian 13 machine with 2 vCPU, 3 GB of RAM (2,893 MB visible to the system) and a 40 GB disk. Both installers started at the same moment, so they shared the same network and the same mirrors.

Our first attempt used lightweight Linux containers (LXC-style) instead of full virtual machines, and Dokploy failed there. Its installer noticed the container and switched to a compatibility mode, but its database service still failed to start in a loop with stat /proc/sys/net/bridge/bridge-nf-call-iptables: no such file or directory. Docker needs a kernel module that a container cannot load for itself. On full KVM virtual machines both installed without an error, so pick a KVM VPS, where you get your own kernel, rather than a container-based "VPS".

Installing both: one command each

Start from a fresh server, logged in as root. Ports 80, 443 and 3000 must be free, because the Dokploy docs say the install fails if any of them is in use. First make sure curl is there:

# as root, on a fresh Debian 13 server
apt-get update
apt-get install -y curl ca-certificates

Then run the official installer for the tool you chose. For Coolify:

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

It works through nine numbered steps. Ours installed Docker Engine 29.9.0, pulled its images in 1 minute 12 seconds and ended with Coolify is ready! Installed in 2m 20s, followed by the dashboard address http://YOUR_SERVER_IP:8000 and a reminder to save /data/coolify/source/.env, which holds the installation's secret keys.

For Dokploy:

# as root
curl -sSL https://dokploy.com/install.sh | sh

Dokploy installs Docker 28.5.0 and holds that version, turns the server into a one-node Docker Swarm (Docker's built-in cluster mode) and pulls its images. After 3 minutes 22 seconds it printed Congratulations, Dokploy is installed! and the address http://YOUR_SERVER_IP:3000. With either tool, open the address and create the admin account at once: until you do, the first visitor becomes the owner.

Idle RAM and disk: the numbers from our lab

We measured memory and disk with three standard commands you can run on any server:

# as root
free -m
df -m /
docker stats --no-stream

free -m shows memory in megabytes, df -m / used disk, and docker stats each container's memory. Results right after install, then 20 minutes later with the same small app and a PostgreSQL database on each:

The gap is mostly one process. Dokploy's dashboard, a Node.js application, held 916 MB of private memory (memory that can't be freed as cache) at idle. Coolify's main container held 157 MB of private memory plus about 250 MB of file cache the system can reclaim. That difference is noise on an 8 GB server and a real problem on a 2 GB one. Builds need headroom too: while Coolify rebuilt our app from scratch, memory use peaked at 2,017 MB on the 2,893 MB machine.

Deploying the same Node.js app on each

We deployed one public repository on both: Render's own express-hello-world, a small Express app under the MIT license. On each, we created an app from the public Git URL with the Nixpacks build pack (it reads your code and works out how to build it without a Dockerfile), set port 3001 and deployed. We drove both through their APIs, which do the same as the dashboard buttons.

Watch the Node.js row. Both tools ran Nixpacks 1.41.0, whose Node provider docs name Node 18 as the default. On Coolify our app came out on Node 22; on Dokploy it fell back to Node 18, which the Node.js release page lists as end-of-life. The app worked either way, so the old runtime is easy to miss. The fix in Dokploy is one environment variable on the app's Environment tab, followed by a redeploy:

# Dokploy app, Environment tab
NIXPACKS_NODE_VERSION=22

After that, node -v inside the container answered v22.11.0, the same version Coolify had used. The same docs say Nixpacks also reads the engines field in package.json, which keeps the choice in your code wherever you deploy it (we tested only the variable).

Databases took one click (or one API call) on each; Coolify's PostgreSQL reported healthy in under 30 seconds. Coolify started PostgreSQL 16 and Dokploy PostgreSQL 18, at 22 MB and 42 MB of RAM when idle. Both tools also show an internal connection string, so the app reaches the database over a private Docker network without opening a port to the internet. For tuning the databases themselves, see our guide to PostgreSQL, MySQL and Redis on a VPS.

Git push, webhooks, build packs and HTTPS

Deploying on every git push is what makes either tool feel like Heroku. We did not connect third-party accounts in the lab, so this part comes from the docs. Coolify links to GitHub through a GitHub App, so every push deploys and every pull request can get its own preview address (Coolify GitHub docs). Dokploy deploys GitHub repositories on push once the GitHub provider is connected, and takes a webhook URL for GitLab, Bitbucket, Gitea and Docker Hub (Dokploy auto-deploy docs). Both also have an HTTP API a CI pipeline can call, which we used for every lab deploy. One gotcha: Coolify's deploy endpoint now answers a GET with This endpoint has changed to a POST request.

Build options overlap almost completely. Coolify offers Nixpacks, Railpack (beta), Static, Dockerfile and Docker Compose (build packs). Dokploy offers Nixpacks, Railpack, Dockerfile, Heroku and Paketo buildpacks and Static (build types), with Docker Compose as a separate service type.

For HTTPS, both docs describe Let's Encrypt certificates issued through Traefik once a domain's DNS points at the server, and Coolify also supports Caddy as its proxy. With no public domain in the lab, we tested routing with local hostnames, and both served the app through their proxy on port 80. Our reverse proxy and SSL guide explains what the proxy does.

Coolify vs Dokploy: the verdict table

Our read: Coolify fits one server packed with apps, especially a small one, because it leaves more memory for your own work. Dokploy fits teams that will spread apps over several servers, or users who want fewer buttons. Coolify's automatic updates save work but can surprise you; you can switch them off in its settings. Hosted prices come from Coolify Cloud and Dokploy Cloud, where they run the dashboard and your apps still run on servers you rent.

What Vercel, Netlify, Railway and Render cost instead

All prices below come from each vendor's official pricing page, checked on 9 October 2026, in US dollars and before tax:

Take a team of three with one Node.js API and one PostgreSQL database. On Render that is the $25 Pro workspace, a $25 web service with 2 GB and a $19 database with 1 GB: $69 a month. On Vercel Pro, three developer seats alone are $60 before any usage, and the database comes from a separate provider. Railway is cheaper for a quiet app, because you pay for what the app actually uses, but the bill grows with every always-on service and every gigabyte sent.

With a self-hosted PaaS, the software costs nothing, nobody charges per seat, and the bill is one server at a flat monthly price. At RS Computers traffic is unmetered, so a busy month doesn't change the invoice. In return, updates, disk space and copies of your databases are your job; our guide to off-site backups with restic and MinIO shows one way to keep them on a second machine.

Which plan size for each

All RS Computers plans run on KVM with NVMe storage, unmetered traffic and their own IPv4 and IPv6 addresses. vCPUs are shared. Based on our measurements:

Watch disk as well as memory. Every build leaves Docker images behind, and our small test already used about 7 GB. Both tools can clean up old images on a schedule, so switch that on. If you outgrow a plan, you can move to a bigger one from the client area with a short reboot. Choose Amsterdam, Dublin or Prishtina on the plans page, where availability by city is shown; servers in Amsterdam and Dublin also get their own /48 of IPv6.

Before you open the dashboard: lock it down

Right after install, both dashboards are plain HTTP on a public port: 8000 for Coolify, 3000 for Dokploy. Create the admin account the minute the installer finishes. Don't count on ufw to hide those ports either: Docker's documentation warns that with ufw, routed container traffic ends up "effectively ignoring your firewall configuration" (Docker docs). Coolify's firewall page says ports 8000, 6001 and 6002 can be closed once the dashboard runs on a domain through the proxy.

Until then, reach the dashboard through an SSH tunnel, which forwards a port on your laptop to the server over your normal SSH login:

# on your own computer (use 3000:localhost:3000 for Dokploy)
ssh -N -L 8000:localhost:8000 root@YOUR_SERVER_IP

Leave that window open and browse to http://localhost:8000. In our lab the machines sat behind a test host, so we ran the same kind of tunnel through that host to each machine's private address; Coolify answered with a redirect to its login page and Dokploy served its sign-in page. Press Ctrl+C to close the tunnel. For alerts when an app goes down, pair either tool with Uptime Kuma or Grafana.

Frequently asked questions

Is Coolify or Dokploy better for beginners?

Dokploy's screens are flatter and quicker to learn, so many beginners feel at home sooner. Coolify has more settings on each screen, but it used about half of Dokploy's RAM in our test and built our app on a supported Node.js version without extra settings. On a small server with 2 to 4 GB, Coolify is the safer start.

How much RAM do Coolify and Dokploy need?

Both projects state 2 GB of RAM as the minimum. In our lab, Coolify's own containers used about 0.5 GB at idle and Dokploy's about 1.1 GB. With one small app and a PostgreSQL database, the whole 2.9 GB machine showed 1.3 GB used with Coolify and 1.8 GB with Dokploy. A 4 GB server is the comfortable minimum for real projects.

Are Coolify and Dokploy really free?

Yes. Self-hosted Coolify is "free forever" under the Apache 2.0 license. Dokploy is free to self-host and Apache 2.0 licensed except for code in folders named /proprietary. Both also sell an optional hosted dashboard: Coolify Cloud from $5 a month and Dokploy Cloud from $4.50 per server a month (checked 9 October 2026).

Can a self-hosted PaaS replace Vercel for a Next.js site?

For most sites, yes. Both tools can build a Next.js app with Nixpacks or a Dockerfile and serve it behind Traefik with Let's Encrypt certificates; we tested a plain Express app, not Next.js. You lose Vercel's global edge network and managed functions; you gain a flat server price instead of Vercel Pro's $20 per developer per month.

Can I run Coolify or Dokploy in an LXC container?

We don't recommend it. In our test, Dokploy's database service failed to start inside an LXC-style container because Docker could not find the kernel's bridge netfilter setting, which a container cannot turn on by itself. Both tools installed cleanly on full KVM virtual machines, which give you your own kernel.

Can I move from Heroku, Railway or Render to Coolify or Dokploy?

Usually yes, because both deploy straight from a Git repository with Nixpacks, buildpacks or a Dockerfile. Connect the repository, copy the environment variables, restore your database from a pg_dump file and switch your DNS. Check which Node.js or Python version the build picks, because defaults differ.

Pick one and push your first app

If you want one server that carries many apps with the least overhead, install Coolify. If you want the simplest screens and a clear path to several servers, install Dokploy. Either way, start on a KVM server, ideally with 4 GB of RAM or more, create the admin account straight away and set your runtime version explicitly. Compare the VPS and VDS plans in Amsterdam, Dublin and Prishtina on the plans page. If you would like us to install Coolify or Dokploy for you, message us on Telegram; setup work is quoted per job.

← All articles