Dokploy Hosting on Liquid Web

Contains affiliate links. Disclosure.

Dokploy itself is free — the only real cost of "Dokploy hosting" is the VPS underneath it. On Liquid Web's Self-Managed line, that's the 4 GB tier at ~$17/mo ($8.50/mo promo for the first two months); the 1 GB entry tier is too tight once Dokploy's own footprint is competing with your apps for RAM.

TL;DR

• Dokploy: self-hosted Docker PaaS. Apache-2.0 core (a /proprietary directory carries a separate, non-open license), ~37k GitHub stars, v0.30.6 (2026-09-08)
• Installs with one command; deploys apps from Git with Nixpacks, Dockerfile, or Docker Compose
• Idle: ~600 MB RAM tested on an older release (see Runtime footprint below), lighter than Coolify (~800 MB idle)
• The cleaner-UI, lower-overhead choice when you need a PaaS without Coolify's extended feature set

Dokploy (github.com/Dokploy/dokploy) is a self-hosted PaaS that deploys applications from Git using Nixpacks (auto-detect language), Dockerfile, or Docker Compose. It manages SSL certificates via Let's Encrypt, runs a Traefik reverse proxy for routing, provisions databases (PostgreSQL, MySQL, MariaDB, MongoDB, Redis), and provides a clean web dashboard for deployments, logs, and environment variables.

Dokploy vs Coolify: both ship most of their code under Apache-2.0. Dokploy carves out a /proprietary directory under a separate commercial license (see github.com/Dokploy/dokploy/blob/main/LICENSE.MD); Coolify's repo is Apache-2.0 throughout. Dokploy is ~200 MB lighter at idle, has a simpler (some say cleaner) UI, and iterates faster on new features. Coolify has a larger community (~62k vs ~37k stars), more production deployments, and a more mature Docker Swarm setup (our hands-on impression, not a documented spec). The self-hosted DevOps & PaaS hub covers both in more depth. For most solo developers and small teams, the choice is preference, so try both.

🖥️

Liquid Web

Need a self-managed VPS?

Tested on local Docker equivalent to a Liquid Web Self-Managed VPS. Dokploy's 600 MB idle footprint fits comfortably inside the 4 GB Self-Managed tier once you budget RAM for your apps.

From $5/mo · Full root access · No management overhead · Prices subject to change

View Self-Managed VPS →

Not the right fit if you need Docker Swarm at scale or Kubernetes. See When this isn't right for you below before you commit a VPS to it.

Prerequisites

• A Liquid Web Self-Managed VPS. There's no 2 GB tier: the real choice is the 1 GB entry tier ($5/mo) or the 4 GB tier (~$17/mo, $8.50/mo promo for the first two months). Use the 4 GB tier — Dokploy's own ~600 MB idle footprint leaves too little headroom on 1 GB once an app is running. Verify current pricing
• Ubuntu 22.04 or Debian 12
• Root SSH access
• A domain pointing to the VPS IP
• About 10 minutes

Install Dokploy

# Run on the VPS as root
curl -sSL https://dokploy.com/install.sh | sh

The script:

1. Installs Docker Engine if not present
2. Pulls the Dokploy Docker image
3. Starts the Dokploy stack (app + PostgreSQL + Redis + Traefik)
4. Exposes the UI on port 3000

After install:

# Visit http://your-vps-ip:3000
# Create your admin account
# The first user to log in becomes the admin

Point DNS at Dokploy

# DNS records
app1.yourdomain.com.  A  <your-vps-ip>
app2.yourdomain.com.  A  <your-vps-ip>
dokploy.yourdomain.com.  A  <your-vps-ip>

In Dokploy: Settings → Server → set the server hostname. Traefik handles SSL automatically for any domain you add to an application.

Deploy your first application

# In the Dokploy UI:
# 1. Projects → Create Project
# 2. + Create Service → Application
# 3. Configure:
#    - Provider: GitHub / GitLab / Bitbucket / Git (custom URL)
#    - Repository and branch
#    - Build type: Nixpacks (auto-detect) / Dockerfile / Docker Compose / Static
# 4. + Create Domain → enter your app's domain
#    Traefik auto-issues an SSL certificate via Let's Encrypt
# 5. Deploy

# Nixpacks language detection covers:
# Node.js, Python, Ruby, Go, PHP, Java, Rust, .NET, Elixir, Crystal

The Docker Compose build type also works for stacks that ship their own compose file: Plausible and Outline both deploy this way if you want analytics or a wiki running alongside your apps.

Deploy a database

# In your project:
# + Create Service → Database → PostgreSQL / MySQL / MariaDB / MongoDB / Redis

# Dokploy provisions the container with:
# - Auto-generated credentials
# - Internal connection string for your apps
# - Automated backup schedule (optional)
# - One-click restore from backup

Inject the database URL into your app as an environment variable via the app's Environment section.

Verify the installation

# Check Dokploy stack is running
docker ps | grep dokploy

# Service health (from VPS shell)
curl -s http://localhost:3000/api/health

# Resource usage
docker stats --no-stream | grep dokploy

Runtime footprint

Measured 2026-05-02 on local Docker (4 vCPU / 8 GB RAM). Current release is v0.30.6 (2026-09-08); 19 releases have shipped since that test, and we haven't re-run it, so treat the numbers as a starting estimate rather than a current spec.

Dokploy stack itself (before deploying any apps):

Service	Idle RAM
dokploy (main app)	300 MB
traefik (proxy)	50 MB
db (PostgreSQL)	180 MB
redis	20 MB
Total (Dokploy stack)	550 MB

Apps deployed via Dokploy add their own RAM. Size your VPS as: Dokploy overhead (~600 MB) + your app RAM budget.

Upgrading Dokploy

# Dokploy has a built-in update option:
# Settings → Server → Dokploy → Update to latest

# Or via CLI (re-run the install script):
curl -sSL https://dokploy.com/install.sh | sh

# Dokploy checks for and applies schema migrations automatically on startup

Cost vs Heroku / Railway

	Heroku Eco (3 apps)	Railway Hobby	Dokploy on Liquid Web
Monthly cost	$15/mo (3 × $5 Eco dyno)	$5/mo usage credit, then metered	$17/mo VPS (4 GB tier; $8.50/mo promo for 2 months)
Apps	3	Unlimited	Unlimited
Databases	Add-on pricing	Add-on pricing	Included (self-managed)
Build minutes	N/A (Git/Docker deploy)	Metered past the $5 credit	On your VPS hardware
Custom domains + SSL	✓	✓	✓ (automatic)
Self-hostable	✗	✗	✓

The Dokploy column is the 4 GB Liquid Web tier this guide's prerequisites actually recommend, not the cheaper 1 GB entry tier. Comparing that would understate the real cost. Prices subject to change. Verify at heroku.com/pricing, railway.com/pricing, and liquidweb.com/vps-hosting/self-managed/, checked 2026-09-09.

Coolify vs Dokploy: which to choose?

	Coolify	Dokploy
Idle RAM	~800 MB	~600 MB (older test, see Runtime footprint)
GitHub stars	~61.6k	~37.2k
Multi-server	✓	✓ (Remote Servers + Swarm Nodes)
Docker Swarm	✓	✓, but Dokploy's own docs flag more setup complexity and no automatic storage cleanup on the extra nodes
UI design	Functional, feature-dense	Cleaner, simpler
Release cadence	Frequent beta patches	Frequent (13 releases in the 3 months to 2026-09-09)
License	Apache-2.0	Apache-2.0 core, plus a proprietary carve-out

Both are solid choices. Use Coolify if you want the larger community and, in our hands-on use, the more turnkey Swarm setup. Use Dokploy if you want a leaner footprint and a cleaner UI at the cost of a smaller community. Stars and release counts verified against the GitHub API on 2026-09-09; Swarm behavior against Dokploy's deployment-options docs the same day.

When this isn't right for you

• You need Docker Swarm at scale, hands-off. Dokploy supports Swarm via its Cluster / Swarm Nodes feature, but its own docs warn of "more setup and operational complexity" and that it "does not perform automatic storage cleanup on the extra nodes." In our testing, Coolify's Swarm setup needed less babysitting. That's a hands-on impression, not a documented spec gap.
• You need Kubernetes. Dokploy is not a Kubernetes platform. For K8s, consider a managed cluster (Liquid Web does not currently offer managed Kubernetes, so verify at the time of purchase) or Rancher/K3s on a dedicated server.
• You have a large team with complex access control. Dokploy's role-based access is simpler than enterprise IAM. For SAML/SSO requirements, neither Dokploy nor Coolify's OSS version covers this, so evaluate the enterprise tiers.
• Uptime is mission-critical. Dokploy is single-server by default. If the VPS goes down, all apps go down. Add monitoring, have a tested restore procedure, and consider the Liquid Web Managed VPS for hardware replacement SLAs.

Exit strategy

Apps deployed via Dokploy are standard Docker containers, fully portable:

# Export the docker-compose.yml for any application:
# Application → General → View Compose → Copy

# Download database backups:
# Service → Database → Backups → Download

# Your application code stays in your Git repository — zero lock-in

Frequently Asked Questions

Yes. In Application settings, set 'Build Path' to the subdirectory of your service within the monorepo. Nixpacks detects the language from that subdirectory. For Docker-based deployments, set 'Dockerfile Path' to the specific Dockerfile location. Each service in the monorepo is a separate Dokploy Application pointing to the same repository with different build paths.

Yes, as of the current release (v0.30.6); that wasn't true when we first wrote this guide. Preview Deployments are GitHub-only and off by default: enable them per application, and Dokploy spins up an isolated environment for each pull request against your target branch, comments the preview link on the PR, and tears it down when the PR closes. Default cap is 3 concurrent previews per app. Dokploy's own docs warn against enabling it on public repos, since anyone who opens a PR can trigger a build on your server.

Dokploy adds a management layer on top of Docker Compose: a web UI for deployments, automatic SSL certificate issuance, environment variable management, deployment logs, database provisioning, and Git webhook integration. If you're comfortable managing Docker Compose files and Caddy/Nginx config manually, Dokploy saves you the operational overhead of doing it yourself. If you have one app and it never changes, raw Docker Compose may be simpler.

The apps themselves are portable: your docker-compose.yml works on any Docker host. Export your compose file from Coolify, import it to Dokploy as a Docker Compose application. Databases need a pg_dump/restore. Environment variables need to be re-entered. The migration is manual but straightforward since both platforms are Docker-based.