This is not a comparison between two hosting platforms. Kamal is a deployment tool — an open-source CLI from 37signals that SSHes into servers you provide and orchestrates Docker containers on them. PandaStack is a managed platform that owns the servers, the builds, the databases, and the routing. Comparing them is really comparing two philosophies: own your infrastructure, or rent the outcome.
Both are legitimate. I run a platform for a living and I'll still tell you there are teams that should absolutely pick Kamal. Let's get specific about which ones.
What Kamal actually is
Kamal (formerly MRSK) came out of 37signals' decision to leave the public cloud and run their products on their own hardware. It's MIT-licensed, free, and installable as a Ruby gem. You point it at one or more servers via SSH, and it:
- installs Docker on them (
kamal setup) - builds your app's Docker image and pushes it to a registry
- pulls and starts containers on each host with zero-downtime cutover
- routes traffic through kamal-proxy (Kamal 2 replaced Traefik with their own purpose-built proxy)
- provisions Let's Encrypt certificates automatically (Kamal 2)
- runs supporting services — Postgres, Redis, and so on — as "accessories"
Configuration lives in one file, config/deploy.yml, and the daily driver commands are short: kamal deploy, kamal rollback, kamal app logs. The docs at [kamal-deploy.org](https://kamal-deploy.org) are genuinely good — terse, complete, honest about what the tool does and doesn't do.
What Kamal does well deserves stating plainly: it gives you the ergonomics of a PaaS-style deploy on hardware you fully control, with zero platform lock-in and zero platform fees. The tool is proven — 37signals runs Basecamp and HEY on it. If you already know how to run servers, Kamal removes most of the deployment drudgery without taking away any control.
Deployment model
Kamal: you provision servers first — a VPS from Hetzner or DigitalOcean, bare metal, EC2 instances, whatever answers SSH. You write config/deploy.yml naming your image, registry, hosts, and env vars, then run kamal deploy. The build happens on your machine or a nominated build host. Kamal 2 can host multiple apps on one server, which makes a single mid-sized VPS go a long way.
PandaStack: you connect a Git repo. The platform builds it (any Dockerfile, or auto-detected buildpacks for Node.js, Python, Go, and more) using rootless BuildKit in ephemeral Kubernetes jobs, and every git push deploys. There's no server to name because there's no server you manage — apps run on multi-region GKE behind Kong ingress, with custom domains and automatic SSL.
The practical difference shows up on day 30, not day 1. With Kamal, the deploy is solved but the server is yours: OS patching, disk monitoring, SSH hardening, firewall rules, and 3 a.m. pages when the host degrades. Kamal explicitly does not manage servers — that's the deal, and its docs don't pretend otherwise. With a managed platform, those pages are someone else's (mine, some weeks).
Databases — the biggest real difference
Kamal runs databases as accessories: a Postgres or MySQL container declared in deploy.yml, started on a host you pick, with a Docker volume for data. See the [accessories docs](https://kamal-deploy.org/docs/configuration/accessories/). It works, and for a single-server setup it's pleasantly simple.
But an accessory is an unmanaged database. Backups, restore drills, version upgrades, connection limits, disk sizing, replication if you ever need it — all yours. Nothing in Kamal will take a nightly backup or alert you that the data volume is full. Plenty of Kamal users solve this by pairing it with a separately managed database service, which is a reasonable pattern but means a second vendor and hand-copied credentials.
PandaStack's databases (PostgreSQL, MySQL, MongoDB, Redis) are managed: scheduled daily backups plus manual ones, retention tied to plan (7 days free, 15 on Pro, 30 on Premium), and — the part that saves the most fumbling — DATABASE_URL injected automatically into any app the database is attached to. No secrets file, no copying connection strings between dashboards.
Developer experience
Kamal's DX is a good CLI and a YAML file. If you like reading exactly what will happen and having every knob in version control, it's satisfying. Secrets go in .kamal/secrets, logs come from kamal app logs, rollback is one command that restarts the previous image. The mental model is small enough to hold in your head, which is rarer than it should be in deployment tooling.
What you don't get: a dashboard, live build logs in a browser, metrics without wiring up your own stack, team roles, or an audit trail of who deployed what. 37signals' answer is that you compose those from other tools, and for a team with ops muscle that's fine.
PandaStack gives you those out of the box — live build and app logs, deployment history with rollbacks, server-side metrics and analytics with no client SDK, organizations with owner/admin/member roles, SSO. The trade is that you're inside a platform's opinions rather than composing your own stack.
Scaling and cost shape
Kamal: scaling is adding hosts to deploy.yml and re-running deploy. It's manual, but VPS pricing makes raw compute very cheap, and cost is flat and predictable — the tool itself costs nothing (see [github.com/basecamp/kamal](https://github.com/basecamp/kamal)). At significant, steady scale, owning servers is usually the cheapest option on paper. The line item that doesn't appear on the invoice is engineering time.
PandaStack: plans are Free ($0), Pro ($15/mo), and Premium ($25/mo), with usage-based compute per hour on top for bigger tiers — from a free 0.25 CPU / 512 MB tier up to 8 CPU / 16 GB compute-optimized instances. Free-tier apps scale to zero when idle (cold start on the next request) and run on preemptible nodes, which is how the $0 tier stays sustainable — and also an honest limitation if you need always-hot responses on free.
The crossover math is roughly this: if you have steady, predictable load and someone who enjoys running servers, Kamal on a beefy VPS wins on raw dollars. If your load is spiky, your team is small, or the person who'd run the servers is also the person who should be shipping features, the managed platform wins on total cost.
Where Kamal is the better fit
- You want zero lock-in and full control, and you have (or are) an ops person.
- Steady load where a fixed VPS bill beats any usage-based pricing.
- Compliance or data-residency needs that require hardware you choose.
- You're a Rails shop that trusts the 37signals toolchain — Kamal fits that world natively, though it deploys any containerized app.
Where PandaStack is the better fit
- You want
git pushto be the whole deployment story, with builds, SSL, domains, and logs handled. - You need a managed database with real backups and don't want to be your own DBA.
- A small team where nobody wants to own OS patching and server monitoring.
- Spiky or hobby workloads where scale-to-zero and a genuinely free tier (5 web services, 5 static sites, 1 database, 100 GB bandwidth) matter.
References
- Kamal documentation: https://kamal-deploy.org
- Kamal accessories (databases): https://kamal-deploy.org/docs/configuration/accessories/
- Kamal source: https://github.com/basecamp/kamal
- PandaStack pricing: https://pandastack.io/pricing
Kamal is what deployment tooling looks like when a capable team decides to own everything — and if that's you, use it without apology. If you'd rather own none of it, the other path takes about five minutes to evaluate on https://pandastack.io.