I built a lightweight Coolify-style PaaS: one Go binary, ~200 MB idle, no Postgres to babysit

The moment that started this was a small one. I had a 2 GB VPS running a deploy platform and one side project, and the platform used more memory than the project. I was paying for the tool that deploys my app more than for the app.

That is not a knock on any tool. A web app with its own database, cache and proxy is a normal way to build a PaaS. I wanted to see what it looked like with fewer parts. I built Levelrail, an open source (Apache 2.0) deploy platform for your own servers: one Go binary with SQLite inside. This post is what I chose, what it costs, what I measured, and where Coolify is still the better choice.

TL;DR

Question Short answer
What is it One control plane binary, SQLite in WAL mode, embedded Caddy ingress and dashboard
Idle footprint About 200 MB resident on a 2 vCPU, 8 GB test box, no apps under load (docs/benchmarks.md)
How it reaches other servers A small agent dials out to the control plane over mutual TLS, no inbound port on the node
Where Coolify wins Maturity, the size of its community, a wide one-click service catalog, nothing to install on managed servers
Where I am honest Single node is the best tested path, and I have not measured Coolify's idle memory

What "no Postgres to babysit" means

Coolify's installer sets up a main application container, a PostgreSQL container named coolify-db and a Redis container named coolify-redis. <!-- source: https://coolify.io/docs/get-started/installation --> That design makes sense. It also gives your platform its own database to back up, upgrade and watch.

Levelrail keeps desired state, settings, deploy history, audit rows and encrypted secrets in a SQLite file in its data directory, with separate SQLite files for telemetry and alerting to keep their writes away from the main one. Container state is not copied anywhere. Docker is the source of truth for what is running.

The trade is real. SQLite is one writer and many readers, so the control plane is a single process on a single host. For a solo developer or a small team that is fine. For a platform team that wants an external HA database, it is the wrong shape.

The footprint, with the box named

The README says about 200 MB idle. Here is where that comes from. The benchmarks page records a live instance on a 2 vCPU, 8 GB test box with all features at defaults and no apps under load: idle RSS 200 MB, peak 253 MB, 273 goroutines, 1.5 percent CPU. A separate run inside a Linux container on Docker Desktop recorded 212 MB resident at zero apps and 216 MB at five stopped apps.

I also ran the current build for this article on my own Apple M4 Max laptop, started with levelrail-cli dev. Resident memory sat near 200 MB shortly after boot and dropped to about 90 MB eight minutes later, after the runtime returned boot-time garbage to the OS. That machine was busy with other work and I took two readings, so read it as a rough range, not a benchmark.

Two caveats from the performance page matter. The runs use dev builds, and the docs show no bare-metal or cloud VM run yet. Real running apps add probe and metrics load that the idle numbers do not include. I did not measure Coolify's memory use at all. Its docs list 2 cores, 2 GB RAM and 10 GB of disk for the server, and say smaller servers work but are not recommended. <!-- source: https://coolify.io/docs/get-started/installation --> That figure covers the whole server, so it says nothing about the platform's own share, and I will not pretend it does.

An agent that dials out, instead of SSH

Coolify manages each server over SSH from the control plane. <!-- source: https://coolify.io/docs/get-started/introduction --> The upside is real: it works with any server you can log into, with nothing extra installed beyond Docker.

Levelrail runs a node agent instead. It dials out to the control plane over gRPC with mutual TLS and talks to the Docker Engine API directly, so nothing shells out to the docker CLI and managed servers need no inbound port. A new server joins with a single-use token that expires after 15 minutes by default.

The cost is a second binary to run on every extra node. Multi-server is also the less proven path: the docs say single node is where most of the testing happened, and I know of checks for the add-a-node flow only against a real local Docker daemon, not across real cloud providers.

One deploy that fails safely

A lightweight platform still has to do the boring part right. Here is a throwaway test I ran on a local instance. I pushed a Dockerfile app, then pushed a second version that reports unhealthy on /healthz.

levelrail-cli apps health set my-app --probe readiness --path /healthz --interval 5s # push the commit, then watch deploy history levelrail-cli apps deploys list my-app 

The second version built, started and never became ready. The deploy was recorded as failed with the reason ReadinessFailed and the message readiness probe: never became ready (context deadline exceeded), last attempt: GET /healthz returned 500, expected 200-299. Meanwhile I requested the app every 3 seconds for the whole window and got 200 from the old version each time.

Getting back to an older release is one command:

levelrail-cli apps deploys rollback-to my-app <DEPLOY_ID> 

I ran it against the first good deploy and the app went back to serving the old version. Levelrail pins previous images so cleanup cannot remove a rollback target. This ran on my laptop against a local Docker daemon, so there was no DNS, no public TLS and no real network between the pieces.

Side by side

This is architecture, not a ranking. Coolify is the older and larger project.

Coolify Levelrail
Server management SSH from the control plane Agent dials out over mTLS, Docker Engine API
Platform state A PostgreSQL container plus Redis SQLite files in one data directory
Runs as A web application with its own database One control plane binary, one agent binary per extra node
Ingress Traefik, Caddy also offered Caddy embedded in the control plane
Maturity and community Established, large catalog Smaller community and catalog, active development
Third-party servers Any server you can reach over SSH Needs the agent installed

Where Coolify is the better pick

If Coolify already does what you need and your team knows it, stay. It has been around longer, more people have hit its edge cases, and its one-click catalog of maintained Compose templates is large. <!-- source: https://coolify.io/docs/get-started/introduction --> Levelrail ships a catalog too, but the end-to-end suite deploys a sample, not every entry, and I would not claim parity.

Coolify also wins when you want to manage servers you cannot or will not install anything on. SSH only is a genuinely simpler story.

If you are thinking of switching, the importer reads a Coolify instance through its API and changes nothing there. Databases and volumes come across empty, so you copy the data yourself. Start with a dry run:

levelrail-cli import platform coolify --url "$COOLIFY_URL" --dry-run 

I did not run the importer for this article, because I have no Coolify instance to point it at. That line comes from the Levelrail docs.

FAQ

Is Levelrail a drop-in replacement for Coolify?

No. The job is the same, deploying apps and databases to your own servers, but the design differs. The importer helps with the move, and the migration guide lists what maps and what does not.

Do I need more than one server?

No. One server is the best tested path. Extra servers join with a one-time token and a small agent.

How do I deploy by pushing code?

Connect GitHub, GitLab, Bitbucket or Gitea and pushes to the branch build and deploy through webhooks. A native git push remote on your own server also exists, but it is off by default and you switch it on in Settings.

Is it free?

Yes. It is Apache 2.0, one edition, with no license key.

What I would watch

The number I care about is not the idle footprint. It is how the same figure looks on a plain 2 GB Linux VPS with ten real apps running, because that is the box this was built for. I have the method to measure it and not yet a published result. If you try it on a small server, I would like to hear what your numbers say.

If this saved you time, a star on the repo helps others find it.

GitHub logo glincker / levelrail

Self-hosted alternative to Vercel and Coolify. Git push, HTTPS, logs, rollback. No Kubernetes.

Levelrail logo

Levelrail

Your own Vercel, on your own servers.
Push to deploy with HTTPS, logs, metrics and one-step rollback. One Go binary, no Kubernetes. Apache 2.0.

GitHub stars License: Apache 2.0 Latest release CI status Last commit levelrail-cli on npm MCP server Discord

Website · Docs · Install · Compare · FAQ · Roadmap · Discussions

English · 简体中文 · Español · Português (BR) · Deutsch · Français · 日本語

Levelrail: your own Vercel, on your server. The lightweight, self-hosted alternative to Vercel, Heroku and Coolify.

Turn any Linux server into a private cloud: Git deploys, HTTPS, databases with verified backups, metrics, logs and alerts, without Kubernetes and without a monitoring stack to bolt on. Pre-1.0: single-server is production ready, multi-node is beta (Feature status).

Levelrail dashboard tour: fleet overview, apps list, deploy history and built-in metrics










200 MB

idle RAM, 1.5% of one CPU
measured, method included

1 binary

Go control plane, Docker runtime
no Kubernetes

360

one-click service templates
smoke-tested

240+

MCP tools for coding agents
scoped, read-only by default

Install

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

Needs Linux (amd64 or arm64) with systemd and root; the installer adds Docker. Open ports…




Sources checked