Levelrail vs Coolify, Dokploy, CapRover, Dokku and Kamal

[thegdsks]

You can run your own apps on your own servers without learning Kubernetes, and you have more than one good way to do it. Coolify, Dokploy, CapRover, Dokku and Kamal are all active projects with real users, and any of them could be the right call. Levelrail is the newest of the group and has the shortest track record. We would rather say that first.

Below is how the six differ in practice: how each reaches your servers, what keeps things running, and where Levelrail made different choices. Facts about the other projects come from their own docs and repositories, linked inline. Facts about Levelrail come from our comparison page. These projects ship fast, so check their docs before you commit.

Contents

• Two architecture styles
• The big table
• The tools, one by one
• Pick Levelrail when
• What you get in the box
• Try it

Two architecture styles

Most of the difference comes down to who starts the conversation between the control plane and your server.

Coolify and Kamal connect to servers over SSH. Coolify's docs say it "connects to each server over SSH" and handles builds, deployments, domains and health checks from there. Kamal, per its site, boots a fresh server with an SSH key and runs imperative commands, "like Capistrano". Levelrail puts a small agent on each node instead. The agent dials out to the control plane over gRPC with mutual TLS, streams Docker events up, and talks to the Docker Engine API directly.

flowchart LR
  subgraph S[SSH style: control plane reaches in]
    C1[Control plane or CI] -->|SSH, inbound port 22| N1[Server]
    N1 --> D1[Docker CLI and Compose]
  end
  subgraph A[Agent style: node dials back]
    N2[Node agent] -->|gRPC, mutual TLS, outbound only| C2[Control plane]
    N2 --> D2[Docker Engine API]
    D2 -->|container events| N2
    C2 --> R[Reconciler: desired vs observed state]
  end

Loading

Neither style is wrong. SSH needs nothing on the server beyond Docker, which is a real advantage when you just want to try something. The agent style needs no inbound port on managed servers and works behind NAT. It also lets the control plane react to Docker events instead of polling or re-running commands.

The big table

Sourced from the Levelrail comparison page and each project's own docs. "Edition" reflects what the repositories show.

	Levelrail	Coolify	Dokploy	CapRover	Dokku	Kamal
How it reaches servers	Agent dials out, gRPC with mutual TLS	SSH from the control plane	Docker Swarm for multi-node, plus remote servers	Docker Swarm	Runs on the host itself, driven by git push or SSH	SSH from your machine or CI
Orchestration	Level-triggered reconciler over the Docker Engine API	Docker and Compose per resource	Swarm services and Compose	Swarm services	Plugin-based scheduler (Docker local, K3s, Nomad)	None, Docker commands per deploy
Ingress and TLS	Caddy embedded in the control plane	Traefik by default, Caddy offered	Traefik	nginx, Let's Encrypt	nginx by default, Caddy, HAProxy, OpenResty, Traefik via plugins	kamal-proxy
Builds	Dockerfile, Railpack, Compose, static Pages	Git providers, Compose templates	Nixpacks, Dockerfile, buildpacks	CLI and web deploys, several languages	Buildpacks (Herokuish, Cloud Native), Nixpacks, Railpack, Dockerfile	Remote builds
Observability	Metrics, log search, traces, errors in the core	Logs and health checks in the dashboard	Resource metrics, exportable to Grafana and others	NetData	Bring your own	Bring your own
Multi-node	Yes, agents plus WireGuard mesh (beta)	Multiple servers	Yes, via Swarm	Yes, via Swarm	Single server	Many servers over SSH
Edition and licence	One edition, Apache 2.0	Apache 2.0, plus paid cloud	Apache 2.0, with some proprietary directories	Apache 2.0 with added restrictions	MIT	MIT
Best for	Operators who want built-in observability, IAM and audit	Broadest catalog, big community	Swarm-minded teams, modern dashboard	Simple Swarm-based setup	One server, git push simplicity	Minimal deploys from CI

Sources: Coolify intro, Coolify proxy, Coolify repo, Dokploy repo, Dokploy docs, CapRover repo, Dokku docs, Dokku repo, Kamal, kamal-proxy, Kamal repo.

The tools, one by one

Coolify

What it does best, and when to pick it

What it does best. Coolify is the most widely adopted option here. Its repository lists 280+ one-click services, Git deploys from GitHub, GitLab, Bitbucket and Gitea, pull request previews, automatic HTTPS, and team access controls, all under Apache-2.0 (repo). It also has a paid cloud edition if you would rather not host the dashboard. It manages servers you already have over plain SSH, and its README notes that if you stop using it, running resources keep working. Its community is the biggest on this list, so a search for your error message usually finds an answer.

Pick it when you want the broadest template list, a big community to search for answers, and SSH-only server management.

Dokploy

What it does best, and when to pick it

What it does best. Dokploy builds on Docker Swarm for multi-node scaling and integrates Traefik for routing. Its README lists remote server deployment, one-click templates, and monitoring of CPU, memory, storage and network with integrations into Grafana, Datadog and CloudWatch. Builds include Nixpacks, Dockerfile and buildpacks (docs). Swarm is a mature clustering mechanism, and Dokploy did not have to reinvent it.

Pick it when Swarm already matches how you think about clusters and you want a modern dashboard on top. Its licence file is Apache 2.0 with proprietary terms for files under /proprietary directories, so read it for the features you need.

CapRover

What it does best, and when to pick it

What it does best. CapRover uses Docker Swarm for clustering, nginx for load balancing, Let's Encrypt for certificates and NetData for monitoring (repo). It has both a CLI and a web GUI, one-click databases, and an explicit promise of no lock-in: apps keep running if you remove CapRover. It has been around a long time and has a large install base. Its licence is Apache 2.0 with an appendix that restricts redistributing paid features.

Pick it when you want something simple, proven and Swarm-based, with a one-click app store and a CLI.

Dokku

What it does best, and when to pick it

What it does best. Dokku describes itself as "an extensible, open source Platform as a Service that runs on a single server of your choice" (docs). You git push, and it builds from a Dockerfile or buildpacks. It supports several proxies (Caddy, HAProxy, nginx, OpenResty, Traefik) and schedulers (Docker local, K3s, Nomad). It has no separate web service, so idle cost is close to nothing. On a single server its simplicity is hard to beat, and Levelrail does not try to be simpler than it.

Pick it when you have one box, you like the Heroku workflow, and you are comfortable at a command line.

Kamal

What it does best, and when to pick it

What it does best. Kamal is deliberately small. Its site lists zero-downtime deploys, rolling restarts, remote builds and accessory services, run from your machine or CI over SSH. Its companion kamal-proxy is "a tiny HTTP proxy" that coordinates zero-downtime cutover with health checks and automatic TLS, under the MIT licence. There is no control plane, database or agent to run. Minimalism is the point, and Levelrail cannot match it, because Levelrail is a control plane.

Pick it when you want as few moving parts as possible, you are happy deploying from CI, and you do not need a dashboard.

Pick Levelrail when

Levelrail is a single Go binary for the control plane, one agent binary per extra node, and an embedded dashboard, with state in SQLite in WAL mode. That design fits best in these situations.

• You want to answer "why was this slow at 3am" without installing anything. Each node keeps its own metrics (15 second resolution) and logs with full-text search, and the control plane queries them. Alerting and crashloop detection, with the last log lines attached, are built in. See Observability.
• Your team already uses Grafana, Sentry or OpenTelemetry. Logs are readable from Grafana through a Loki-compatible API. Any Sentry SDK can point at the control plane for error tracking. OTLP traces over HTTP are kept on the node and shown as a waterfall.
• You do not want SSO, audit or fine-grained roles behind a plan. There is one edition, Apache 2.0, with no licence key. OIDC and OAuth sign-in, passkeys, TOTP, AWS-style allow and deny IAM policies and an exportable audit log all ship in it. See Identity and access.
• A bad deploy is what worries you. Cutover waits for a real readiness probe, and rollback targets are pinned so image cleanup cannot remove them. After cutover the release is watched for five minutes by default and rolled back automatically if it crashloops or returns too many 5xx errors. Approvals and freeze windows are there too. See Deploy safety.
• You run many small apps and idle cost matters. Apps can sleep when idle and wake on the next request. Performance has measured footprint at 0, 100 and 500 apps, with a way to reproduce it.
• You host static sites alongside services. Pages serves static sites from git with no container, using the embedded ingress.
• You are leaving another platform. A read-only importer with a dry run covers Coolify, Dokploy and CapRover.

Here is a rough way to decide:

flowchart TD
  Q1{One server only?} -->|Yes| Q2{Want zero server software?}
  Q2 -->|Yes, deploy from CI| K[Kamal]
  Q2 -->|No, want git push| DK[Dokku]
  Q1 -->|No, or growing| Q3{Need built-in logs, metrics, IAM, audit?}
  Q3 -->|Yes| L[Levelrail]
  Q3 -->|No| Q4{Biggest template catalog and community?}
  Q4 -->|Yes| CO[Coolify]
  Q4 -->|No| Q5{Docker Swarm already your model?}
  Q5 -->|Yes| DP[Dokploy or CapRover]
  Q5 -->|No| L

Loading

What you get in the box

Area	What ships	Docs
Deploys	Dockerfile and Railpack builds, Compose apps, blue-green, rolling or recreate	Zero-downtime deploys
Safety	Readiness gate, pinned rollback targets, approvals, freezes	Deploy safety
Previews	One per pull request on GitHub, GitLab, Bitbucket and Gitea	Preview environments
Logs and metrics	Node-local, federated query, alerts	Observability
Loki-compatible logs	Grafana reads app logs, no shipper	Loki API
Errors	Sentry SDKs point at your control plane	Error tracking
Traces	OTLP traces kept on the node	Tracing
Static sites	Pages, no container	Pages
Scale to zero	Sleep when idle, wake on request	Sleep when idle
Identity	IAM policies, roles, API token abilities, audit log	Identity and access
Multi-node	Agents, placement, WireGuard mesh	Multi-node
Backups	Scheduled, verified, restorable	Backups and storage
Templates	311 one-click Compose templates	Templates
AI access	MCP server, read-only by default, never in the reconcile path	MCP

Try it

On a Linux server:

curl -fsSL https://levelrail.com/install.sh | sudo sh

Then follow Getting started, which gets you to a first deployed app in about ten minutes. If you run Coolify, Dokploy or CapRover today, start with the importer's --dry-run, which only reads from the old instance.

• Star the repo: github.com/glincker/levelrail
• Read the full comparison page
• If we got a fact wrong about any project here, reply in this thread and we will fix it. We also want to hear what would make you switch, or what would stop you.