# Temps vs Kamal

> Compare Temps and Kamal (by 37signals) for deploying your applications. Full PaaS vs deployment tool.

Last updated 2026-11-03

Canonical: https://temps.sh/compare/vs-kamal

From deployment tool to full platform

## Short answer

Kamal is a CLI from 37signals that builds a Docker image and pushes it to servers over SSH: no web dashboard, no persistent control plane, no database management and no monitoring, and nothing left on your machines except Docker. Temps is a platform — a control plane with a web UI, git-push deploys with preview environments, managed Postgres (with HA), MariaDB, MongoDB and Redis, and analytics, error tracking, session replay and uptime monitoring included. What Kamal has that Temps doesn't: A far smaller surface area: no agent on your servers, nothing to keep patched beyond Docker. Both are free and both deploy containers to hardware you own; what differs is how much runs on your machines.

## TL;DR

| Dimension | Temps | Kamal | Better fit |
| --- | --- | --- | --- |
| What it is | Full self-hosted PaaS with a dashboard | CLI deploy tool, no control plane | Tie |
| Built-in observability | Analytics, errors, replay, uptime | None — bring your own | Temps |
| Managed databases | Postgres (with HA), MariaDB, MongoDB, Redis | Plain Docker containers, no HA | Temps |
| Git-push deploys and preview URLs | Built in | Manual CLI deploy; wire up your own CI | Temps |
| Footprint on your servers | Control plane agent required | Nothing beyond Docker | Kamal |

## Key differences

- **Full PaaS, not just a deploy tool:** Kamal is a CLI-only deployment tool — no web UI, no dashboard, no git-push triggers. Temps is a complete platform with a web interface and automated workflows.
- **Built-in observability:** Kamal has zero built-in monitoring. You need Sentry, PostHog, Pingdom, and a logging stack separately. Temps includes analytics, error tracking, session replay, and uptime monitoring.
- **Nothing to install on your laptop:** Kamal is installed as a Ruby gem (or run through its Docker image) on the machine you deploy from, and deploys run from there. Temps runs on the server: install it once with one command and deploys start from a git push.
- **Git-push deploys out of the box:** Kamal needs GitHub Actions or CI/CD glue for automated deploys. Temps supports native git-push deployment with zero configuration.

## Features

| Feature | Temps | Kamal |
| --- | --- | --- |
| Git push deployments | Yes (Native) | No (Requires CI/CD setup) |
| Web dashboard | Yes (Full management UI) | No (CLI-only) |
| Docker support | Yes | Yes |
| Zero-downtime deploys | Yes | Yes |
| Automatic SSL | Yes (Automatic) | Yes (Via kamal-proxy and Let's Encrypt, single-server deploys only; multi-server needs your own certificates) |
| Custom domains | Yes | Yes |
| Preview environments | Yes (Per pull request) | No (Manual setup required) |
| Managed PostgreSQL | Yes (HA clusters) | No (Docker accessory (no HA)) |
| Managed Redis | Yes (Included) | No (Docker accessory) |
| S3-compatible storage | Yes (Built-in (RustFS; legacy MinIO supported)) | No |
| Error tracking | Yes (Sentry-compatible) | No |
| Analytics | Yes (Privacy-first, unlimited) | No |
| Session replay | Yes (Built-in) | No |
| Uptime monitoring | Yes (Built-in checks + alerting) | No |
| Transactional email | Yes (Through SES, Scaleway or an SMTP relay) | No |
| Multi-server support | Yes | Yes |
| Rolling deployments | Yes | Yes |
| Open source | Yes (MIT / Apache 2.0) | Yes (MIT) |

## Pricing

| Item | Temps | Kamal |
| --- | --- | --- |
| Self-hosted | $0 | $0 |
| Cloud version | Invite-only beta | N/A (no cloud offering) |
| With full observability | $0 (included) | $0 + several tools to run yourself, or paid SaaS from $26/mo |
| With managed databases | $0 (included, HA) | $0 (basic Docker containers, no HA) |

Both are free and open-source. But Kamal is a deployment tool only — adding a dashboard, observability, managed databases, and preview environments means integrating 5+ separate tools. Temps includes everything.

## Choose Temps if

- You want a full PaaS with a web dashboard, not just a CLI tool
- You want git-push deploys without configuring GitHub Actions
- You need built-in analytics, error tracking, and monitoring
- You want preview environments for every pull request
- You need managed databases with HA support
- You want deploys to start from a git push, not from a laptop or a CI job you maintain

## Choose Kamal if

- You want the simplest possible deployment — just SSH + Docker
- You prefer a minimal tool with no server-side control plane
- You're deploying Rails apps and want first-party Basecamp tooling
- You already have a mature observability stack you're happy with
- You want zero dependencies on your servers beyond Docker

## Migrating from Kamal (easy)

Temps has a Kamal import wizard. Kamal keeps no server-side state, so the wizard reads your config/deploy.yml directly and recreates the service it describes as a Temps project: the image, its environment variables and a live deployment. Accessories such as Postgres or Redis are better moved to Temps-managed services with a dump and restore. Afterwards, connect the Git repository so deploys start on push instead of from your machine. No application code changes.

[Step-by-step: migrate from Kamal with the import wizard](https://temps.sh/docs/from-kamal)

## FAQ

### Is Temps better than Kamal?

It depends on how much platform you want. Kamal is better if you want the smallest possible deployment tool: SSH plus Docker, no control plane, nothing running on your servers that you did not put there. Temps is better if you want a dashboard, git-push deploys, managed databases, and analytics, error tracking, session replay and uptime monitoring included rather than assembled from separate tools. Kamal deploys apps; Temps runs a platform.

### What is the difference between Temps and Kamal?

Kamal is a command-line tool from 37signals that builds a Docker image and pushes it to servers you specify over SSH. It has no web dashboard, no persistent control plane, no built-in database management and no monitoring. Temps is a self-hosted PaaS: a control plane with a web UI, git-push deploys with preview environments, automatic SSL, managed PostgreSQL/MariaDB/MongoDB/Redis, and built-in observability. Both deploy Docker containers to servers you own.

### Can I migrate from Kamal to Temps?

Yes. The Temps import wizard reads your config/deploy.yml (Kamal has no server-side API to query) and recreates the service as a Temps project with its image, environment variables and a live deployment. Move accessories such as Postgres or Redis into Temps-managed services with a dump and restore, then connect your Git repository so deploys trigger on push. Your images and code need no changes.

### Does Temps replace Kamal entirely?

For most teams, yes. Temps covers everything Kamal does — building images, deploying containers to your own servers, zero-downtime rollouts, environment variables and secrets — and adds the dashboard, databases and observability Kamal deliberately leaves out. The exception is if you specifically want no control plane on your infrastructure. Kamal's design goal is to leave nothing behind except Docker, and Temps does run an agent.

### Which is cheaper, Temps or Kamal?

Both are free and open source, so the licence cost is zero either way and you pay only for servers. The cost difference appears in what you have to run alongside them: with Kamal you self-host or subscribe to separate analytics, error tracking, session replay and uptime monitoring — several tools to maintain, or paid SaaS from around $26/month. Temps includes those in the same binary at no extra cost.

### Which is better for Rails apps?

Kamal has the edge on affinity: it comes from 37signals, ships as the default deployment path in modern Rails, and its documentation and conventions assume a Rails app. Temps deploys Rails through a Dockerfile or its Ruby preset and gives you managed Postgres and Redis alongside it, but you will find more Rails-specific tutorials for Kamal. If you want first-party Rails tooling, use Kamal; if you want the database and monitoring in the same place, use Temps.

### Does Kamal have a web dashboard?

No. Kamal is intentionally CLI-only — there is no web interface for viewing deploys, reading logs, managing environment variables, or inspecting running containers. You do all of it through the kamal command and SSH. Temps provides a web dashboard for deployments, logs, metrics, databases, domains and the full observability stack, plus a CLI for scripting and automation.

### What does Kamal do better than Temps?

Simplicity and footprint. Kamal has no server-side control plane, so there is nothing on your machines to keep updated, secure or debug beyond Docker itself. It is a smaller tool with a smaller surface area, it is backed by 37signals and used in production at scale by them, and it does not ask you to adopt a platform to deploy a container. Temps is pre-1.0 (v0.1.0 prereleases), with far more moving parts, because it also stores and serves your telemetry.

## Sources

- [Kamal installation](https://kamal-deploy.org/docs/installation/)
- [Kamal configuration](https://kamal-deploy.org/docs/configuration/overview/)
- [Kamal on GitHub](https://github.com/basecamp/kamal)

## Further reading

- [Migrate from Kamal With the Import Wizard](https://temps.sh/docs/from-kamal): Point the wizard at your config/deploy.yml and recreate the service as a Temps project.
- [Deploy Ruby on Rails on Temps](https://temps.sh/deploy/rails): Build a Rails app on Temps with a Dockerfile or the Ruby preset, and link a managed Postgres service.
- [Temps vs Dokku](https://temps.sh/compare/vs-dokku): Another minimal, CLI-driven way to deploy containers to your own servers.
- [Monitoring, alerts and uptime](https://temps.sh/docs/monitoring): What Temps watches out of the box: metrics, alerts and 60-second uptime checks.
- [7 best self-hosted deployment platforms](https://temps.sh/blog/7-best-self-hosted-deployment-platforms-2026): Kamal reviewed next to Temps, Coolify, Dokploy, CapRover, Dokku and Portainer.

---

Source: https://temps.sh/compare/vs-kamal · Index of all pages: https://temps.sh/llms.txt