Nov 17, 20269 min read

Kamal Alternatives in 2026: Deploying to Your Own Servers or Cloud

The main alternatives to Kamal for deploying containers to servers or cloud accounts you control, how they compare on databases, background jobs, scaling and day-two operations, and how to run the backend in your own AWS or GCP account.

Illustration for Kamal Alternatives in 2026: Deploying to Your Own Servers or Cloud

Kamal is the deploy tool 37signals built to move its apps off the cloud, and since Rails 8 it ships in every new Rails app with a config/deploy.yml ready to fill in. You list server IPs, it builds the image, pushes it to a registry and swaps containers over SSH behind kamal-proxy with no downtime, which works well for a web app on a few servers you already run.

It gets harder once the database runs as an accessory container on one of those servers and its backups, failover and upgrades are yours, when a traffic spike needs more servers that someone has to create first, or when the team would rather not hold SSH access to production at all.

This guide compares the main Kamal alternatives on databases, background jobs, scaling and day-two operations, and shows how Encore runs a backend in your own AWS or GCP account with the database and queue declared in TypeScript.

Kamal alternatives at a glance

Runs onDatabasesScalingInterfaceBest for
EncoreFargate, EKS, Cloud Run or GKE in your AWS or GCP accountRDS or Cloud SQL, provisioned from codeManaged by the cloud servicegit push, dashboard, CLIBackends on AWS or GCP with infrastructure declared in code
CoolifyYour servers, managed from a self-hosted or cloud dashboardOne-click database containers with scheduled backupsAdd servers by handWeb dashboardSmall teams on a VPS who want a PaaS-style UI
DokkuOne serverPlugins for Postgres, Redis and moreScale processes on one hostgit push, CLIHeroku-style deploys on a single machine
DokployYour servers, multi-node with Docker SwarmDatabase containers with backups to S3Swarm replicas across nodesWeb dashboardDocker Compose apps across a few servers
Amazon ECS on FargateYour AWS accountRDS, set up separatelyService autoscalingConsole, CLI, IaCTeams on AWS that want managed containers
k3sYour serversOperators or external databasesKubernetes autoscaling with node capacity you addkubectl, HelmKubernetes on your own hardware
KamalAny server reachable over SSHAccessory containersAdd servers to deploy.ymlCLIWeb apps on servers you already run

Kamal 2.12 was the current release when checked on November 17, 2026. Kamal 2 replaced Traefik with its own kamal-proxy and added automatic HTTPS with free TLS certificates, along with support for running several apps on one server.

1. Encore

Encore

Encore brings infrastructure from code to TypeScript and Go backends, so the pieces Kamal runs as accessories on your servers become declarations in the app that Encore provisions as managed cloud services in your own AWS or GCP account. Where a Kamal app has a Postgres accessory and a job container, the Encore version declares a database and a topic with a subscriber, encore run starts both locally, and a push deploys them to Fargate, RDS and SNS/SQS on AWS, or Cloud Run, Cloud SQL and Pub/Sub on GCP, as the infrastructure docs list.

Set up the app

Get started
brew install encoredev/tap/encore &&
encore app create
Copy

Run in your terminal to get started locally.

~
$ encore app create billing --example=ts/hello-world$ cd billing && mkdir -p invoices/migrations

The invoices folder gets an encore.service.ts that exports new Service("invoices") and a migration that creates an invoices table with id, customer_email, amount_cents, created_at and a nullable emailed_at column. The service stores an invoice and hands the email to a subscriber, the job a separate worker container would do in a Kamal setup:

// invoices/invoices.ts import { api, APIError } from "encore.dev/api"; import { SQLDatabase } from "encore.dev/storage/sqldb"; import { Topic, Subscription } from "encore.dev/pubsub"; import log from "encore.dev/log"; // Replaces the Postgres accessory: RDS or Cloud SQL in your account, // started locally by `encore run`. const db = new SQLDatabase("invoices", { migrations: "./migrations" }); interface InvoiceCreated { invoiceId: number; } // Replaces the job container and its queue: SNS/SQS on AWS, Pub/Sub on GCP. export const invoiceCreated = new Topic<InvoiceCreated>("invoice-created", { deliveryGuarantee: "at-least-once", }); interface CreateParams { customerEmail: string; amountCents: number; } export const create = api( { expose: true, method: "POST", path: "/invoices" }, async (p: CreateParams): Promise<{ id: number }> => { if (!p.customerEmail.includes("@") || !Number.isInteger(p.amountCents) || p.amountCents <= 0) { throw APIError.invalidArgument("customerEmail and a positive integer amountCents are required"); } const row = await db.queryRow<{ id: number }>` INSERT INTO invoices (customer_email, amount_cents) VALUES (${p.customerEmail.toLowerCase()}, ${p.amountCents}) RETURNING id`; await invoiceCreated.publish({ invoiceId: row!.id }); return { id: row!.id }; }, ); const _ = new Subscription(invoiceCreated, "email-invoice", { handler: async ({ invoiceId }) => { // Claim the invoice first, so a redelivered message does not email it twice. const inv = await db.queryRow<{ customer_email: string; amount_cents: number }>` UPDATE invoices SET emailed_at = now() WHERE id = ${invoiceId} AND emailed_at IS NULL RETURNING customer_email, amount_cents`; if (!inv) return; log.info("send invoice email", { to: inv.customer_email, amountCents: inv.amount_cents }); }, retryPolicy: { minBackoff: "10s", maxBackoff: "5m", maxRetries: 10 }, });
~/billing
$ encore run$ curl -X POST localhost:4000/invoices -d '{"customerEmail":"ada@acme.dev","amountCents":4900}'{"id": 1}

encore run starts Postgres locally, applies the migration and runs the topic and subscriber in the same process, so the web-plus-worker flow works on a laptop without a deploy.yml, accessory containers or a registry. A handler that throws is retried with backoff from 10 seconds up to 5 minutes and moved to a dead-letter queue after 10 attempts, as the Pub/Sub docs describe, and the claim query returns a row only the first time, which was checked against Postgres 17.

On AWS, Encore creates the VPC, the RDS instance in private subnets with daily backups, the SNS topic and SQS queue, and an IAM role for the service, and on GCP the equivalents, as described in the AWS infrastructure docs. Nobody needs SSH access to a server, and there is no accessory database to back up by hand. An AI coding agent working in this repository can add a second subscriber or another table in the same change, run it against the local Postgres and queue, and push it without touching a deploy file or a server.

If the reason you picked Kamal was to run on your own hardware rather than AWS or GCP, encore build docker produces a standard image of the app that you can self-host anywhere, including with Kamal, pointing it at a database and queue you run yourself.

Best fit: teams that want the backend, its database and its queues running as managed services in their own AWS or GCP account, declared in code and tested locally with encore run.

2. Coolify

Coolify is an open source, self-hosted PaaS with a web dashboard for deploying apps, databases and over a hundred one-click services onto servers you connect over SSH. Self-hosting is free, and Coolify Cloud, where the dashboard runs on Coolify's infrastructure and deploys to your servers, costs $5 a month for two servers plus $3 for each additional one, from its pricing page checked November 17, 2026.

Compared with Kamal it trades a config file for a UI, adds scheduled database backups to S3-compatible storage and preview deployments from pull requests, and still leaves server capacity, OS updates and database failover to you.

Best fit: small teams on one or a few VPSs who want a dashboard instead of a YAML file and SSH commands.

3. Dokku

Dokku is the long-running open source "Heroku on one server": git push dokku main builds the app with buildpacks or a Dockerfile, and plugins add Postgres, Redis, automatic TLS certificates and more. It runs on a single host, which keeps it simple and cheap, and multi-server setups go through its k3s or Nomad schedulers.

For a Kamal user, Dokku is the more opinionated option, with a Heroku-like Procfile and process scaling on one machine rather than containers spread across a server list.

Best fit: side projects and small apps that fit on one machine and want a Heroku-style workflow.

4. Dokploy

Dokploy is an open source deploy dashboard built on Docker, Docker Compose and Traefik, with multi-server deploys through Docker Swarm, database containers with backups to S3, and monitoring per container. It is free to self-host, and its managed plan starts at $4.50 a month per server, from its pricing page checked November 17, 2026.

It suits apps that already have a docker-compose.yml, since Compose stacks deploy as they are, and Swarm adds replicas across nodes that Kamal does not schedule for you.

Best fit: Docker Compose apps spread across a few servers that want a dashboard and basic orchestration.

5. Amazon ECS on Fargate

ECS on Fargate runs containers on AWS without servers to manage: you register a task definition, create a service behind an Application Load Balancer, and Fargate places and replaces tasks, with service autoscaling on CPU, memory or request count. Rolling deployments replace Kamal's container swap, and RDS, ElastiCache and SQS replace accessories with managed services.

The cost is the amount of AWS configuration around it, from the VPC and subnets to task and execution roles, security groups, the load balancer and the pipeline that pushes images to ECR, usually written in Terraform or CDK.

Best fit: teams on AWS that want managed containers and are prepared to own the infrastructure code around them.

6. k3s

k3s is a lightweight, certified Kubernetes distribution that installs as a single binary and runs well on small VMs and bare metal. It gives you the Kubernetes API, Helm charts, rolling updates and the Horizontal Pod Autoscaler on hardware you own, which is the main step up from Kamal when an app grows into many services.

The trade-off is Kubernetes itself, with manifests, ingress controllers, storage classes and cluster upgrades to learn and maintain, and autoscaling still stops at the nodes you have.

Best fit: teams that want Kubernetes on their own servers and have the experience to run it.

How to choose

Stay with Kamal if you run a handful of servers, are happy owning the database and backups, and like a single config file and SSH. Pick Coolify or Dokploy for a dashboard on top of your servers, and Dokku for a Heroku-style workflow on one machine. Pick k3s when the app needs Kubernetes on hardware you own, and ECS on Fargate when you are moving to AWS and want managed containers with infrastructure code you maintain. Pick Encore when you want the backend, database and queues running as managed services in your own AWS or GCP account, with the infrastructure declared in TypeScript or Go next to the code that uses it, and the own-cloud setup connecting your account once.

Frequently asked questions

What is the best alternative to Kamal?

For a single VPS or a few servers, Coolify, Dokku and Dokploy add a dashboard or a Heroku-style workflow on top of Docker. For apps on AWS or GCP, Amazon ECS on Fargate or Google Cloud Run replace server management with managed compute and managed databases in your own account, and k3s suits teams that want Kubernetes on their own hardware.

What does Kamal not do?

Kamal deploys Docker containers over SSH with zero-downtime switching through kamal-proxy, automatic HTTPS and accessories for databases and caches. It does not provision servers, autoscale, back up accessory databases or run managed services for you, so failover, backups and capacity planning stay with your team.

Can I use Kamal on AWS?

Kamal works on AWS with any server reachable over SSH, including EC2 instances. You still create the instances, load balancer, security groups and any RDS database yourself, and Kamal only handles the containers on those instances.

How do I deploy a backend with a database and a queue to my own AWS account without managing servers?

With Encore you declare the database with new SQLDatabase and the queue with new Topic and new Subscription in TypeScript. encore run starts Postgres and the queue locally, and on git push Encore provisions the services on Fargate or EKS, RDS for the database and SNS/SQS for the queue in your AWS account, or Cloud Run, Cloud SQL and Pub/Sub on GCP.

Deploy to your cloud on AWS and Google Cloud
without managing infrastructure

Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.

~/orders — claude
Claude Code
Claude Code v2.1.180Opus 5.5~/orders