Kamal · Self-hosted

Last updated

Temps vs Kamal

From deployment tool to full platform

Monthly cost at a glance

Temps
Kamal
Self-hosted
$0
$0
Cloud version
Coming soon
N/A
With full observability
$0
$0+
With managed databases
$0
$0
$curl -fsSL https://temps.sh/deploy.sh | bash

The short answer

Kamal
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
Temps is a platform — a control plane with a web UI, git-push deploys with preview environments, managed Postgres, MySQL, MongoDB and Redis with HA, 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.

Scored, dimension by dimension

  • What it is

    Tie

    Temps

    Full self-hosted PaaS with a dashboard

    Kamal

    CLI deploy tool, no control plane

  • Built-in observability

    Temps

    Temps

    Analytics, errors, replay, uptime

    Kamal

    None — bring your own

  • Managed databases

    Temps

    Temps

    Postgres, MySQL, Mongo, Redis with HA

    Kamal

    Plain Docker containers, no HA

  • Git-push deploys and preview URLs

    Temps

    Temps

    Built in

    Kamal

    Manual CLI deploy; wire up your own CI

  • Footprint on your servers

    Kamal

    Temps

    Control plane agent required

    Kamal

    Nothing beyond Docker

Why teams switch from Kamal

Kamal deploys containers over SSH. Temps gives you that plus a dashboard, git-push deploys, preview environments, and built-in observability — in a single binary.

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.
No Ruby required
Kamal requires a Ruby environment and Docker on your local machine. Temps is a single Rust binary — install and go.
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.

Feature comparison

What each platform includes out of the box, and what needs a separate subscription.

  • Git push deployments

    Temps

    Yes
    Native

    Kamal

    No
    Requires CI/CD setup
  • Web dashboard

    Temps

    Yes
    Full management UI

    Kamal

    No
    CLI-only
  • Docker support

    Temps

    Yes

    Kamal

    Yes
  • Zero-downtime deploys

    Temps

    Yes

    Kamal

    Yes
  • Automatic SSL

    Temps

    Yes
    Automatic

    Kamal

    Yes
    Via kamal-proxy
  • Custom domains

    Temps

    Yes

    Kamal

    Yes
  • Preview environments

    Temps

    Yes
    Per pull request

    Kamal

    No
    Manual setup required
  • Managed PostgreSQL

    Temps

    Yes
    HA clusters

    Kamal

    No
    Docker accessory (no HA)
  • Managed Redis

    Temps

    Yes
    Included

    Kamal

    No
    Docker accessory
  • S3-compatible storage

    Temps

    Yes
    Built-in (RustFS, MinIO supported)

    Kamal

    No
  • Error tracking

    Temps

    Yes
    Sentry-compatible

    Kamal

    No
    Not available
  • Analytics

    Temps

    Yes
    Privacy-first, unlimited

    Kamal

    No
    Not available
  • Session replay

    Temps

    Yes
    Built-in

    Kamal

    No
  • Uptime monitoring

    Temps

    Yes
    Built-in checks + alerting

    Kamal

    No
    Not available
  • Transactional email

    Temps

    Yes
    SMTP, SES, Scaleway, Cloudflare built in

    Kamal

    No
  • Multi-server support

    Temps

    Yes

    Kamal

    Yes
  • Rolling deployments

    Temps

    Yes

    Kamal

    Yes
  • Open source

    Temps

    Yes
    MIT / Apache 2.0

    Kamal

    Yes
    MIT

What it actually costs

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.

ScenarioTempsKamal
Self-hosted$0$0
Cloud versionComing soonN/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)

Which one should you choose?

Choose Temps if you…

  • 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 don't want to install Ruby or manage a local toolchain

What Kamal does better than Temps

  • 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 difficulty

Kamal apps are Docker-based, so your images port directly. Replace the kamal.yml deploy config with a Temps service definition — most settings have direct equivalents. You gain a web dashboard and native git-push automation that replaces the manual SSH-based deploy workflow. The main learning curve is un-learning Kamal's CLI-centric approach, not any app code changes.

Frequently asked questions

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/MySQL/MongoDB/Redis, and built-in observability. Both deploy Docker containers to servers you own.

Can I migrate from Kamal to Temps?

Yes, and it is straightforward. Kamal apps are already Docker-based, so your images port over directly with no application code changes. You replace the kamal.yml deploy configuration with a Temps service definition — most settings have direct equivalents — and connect your git repository so deploys trigger on push instead of from your laptop. The real adjustment is un-learning the CLI-only workflow, not rewriting anything.

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 perfectly well through Dockerfile or Nixpacks builds 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 a young project (v0.1.0) with far more moving parts.

Ready to switch from Kamal?

Self-host Temps for free, or join Temps Cloud from $29/month for queryable managed telemetry, query compute, and offsite backups.