Compared to other tools

A side-by-side comparison of yoink with Kamal, Kubernetes, Dokku, Coolify, and plain docker compose.

Read as MarkdownEdit on GitHub

Many tools do a similar job to yoink. The correct tool depends on your scale, on the number of operators, and on how much always-on infrastructure you want to operate.

At-a-glance matrix

✓ = built-in, ◐ = partial or opt-in, ✗ = not in scope.

yoinkKamalCoolifyDokkuKomodoUncloudcomposek8s
Single binary, no control plane✓✓✗ (web app + DB)◐ (host-side runtime)✗ (Core + per-host agents)✗ (per-host daemon)✓✗
Always-on services to operatenonenoneCoolify Core + DBDokku on each hostKomodo Core + Peripheryuncloudd per hostnoneetcd + control plane
Config-as-code (YAML, in your repo)✓✓◐ (UI primary, GitOps opt-in)✗ (CLI + buildpacks)◐ (UI primary, “Resource Sync” opt-in)✓✓✓
CLI + files only, no GUI required✓✓✗ (UI is the primary surface)✓✗ (UI is the primary surface)✓✓✓
Agent-friendly (scriptable end-to-end)✓✓◐ (REST API exists, UI-first)✓◐ (API exists, UI-first)✓✓✓
Multiple services per host✓◐ (one container per service per host)✓✓✓✓✓✓
Replicas behind a proxy✓✗✓✗✓✓◐✓
Multi-host✓✓✓✗ (single host)✓✓✗✓
Per-tier network isolation✓✗◐✗◐◐✓✓
Dependency-ordered deploys✓✗✓✗✓✓◐✓
Bundled reverse proxy (HTTPS, ACME)✓ (Caddy)✓ (kamal-proxy)✓ (Traefik)✓ (nginx)✗✓ (Caddy)✗◐ (Ingress controller of choice)
Healthcheck-gated rolling swap✓✓✓◐✓✓✗✓
Drift detection✓✗✗✗✓✓✗✓
Pre-merge dry-run / diff✓✗✗✗✗✗✗✓ (kubectl diff)
Sealed in-repo secrets (no external service)✓ (age)✗ (external vault required)✗✗✗✗✗✗
Standalone deploy (no registry, no CI)✓✗✗✓ (git push)✗✗✓ (local)✗
Secure-by-default container options✓✗✗✗✗✗✗◐ (Pod Security Standards)
Port-forward to non-published services✓ (yoink pf, auto-spawns socat sidecar)✗✗✗✗✗✗✓ (kubectl port-forward)
TUI dashboard✓ (k9s-style)✗n/a (web UI)✗n/a (web UI)✗✗◐ (k9s, third-party)
One-press rollback✓✓✓✓✓✓✗✓
Auto-scaling✗✗✗✗✗✗✗✓
Multi-tenancy / RBAC✗✗✓◐✓✗✗✓

yoink is ahead on these rows:

  • Single-binary operation.
  • Drift detection.
  • Sealed in-repo secrets.
  • Hardened container defaults.
  • Pre-merge diff.
  • Standalone (no-registry) mode.
  • Port-forward to services that do not publish host ports. In this group of tools, only Kubernetes has the same kubectl-style function.
  • One-line templates (yoink add postgres, yoink add openclaw, yoink add gh:acme/templates/foo). See the templates guide.

yoink deliberately does not compete on auto-scaling, multi-tenancy, and web UIs.

vs. Kamal

Kamal is the nearest tool to yoink. Each one is a binary (Rust for yoink, Ruby for Kamal) that connects to hosts over SSH and drives Docker.

FeatureyoinkKamal
Image buildyoink build [--push] (optional)kamal build (built-in)
Reverse proxyBundled Caddy (admin-API push, mTLS, h2c, sealed certs)First-party kamal-proxy
Replicas (multiple containers per service)✓ (replicas: N)✗ (one container per service per host)
Per-tier networks✓ (networks: [api, redis])✗ (single shared network)
Dependency-ordered deploys✓ (depends_on: topo-sort, parallel waves)✗
Drift detection✓ (yoink.spec_hash label)✗
Pre-merge dry-run / diff✓ (yoink up --dry-run --format=markdown → sticky PR comment)✗
TUI dashboard✓ (k9s-style)✗ (CLI only)
Service deploy history + one-press rollback✓ (TUI H then r)✓ (CLI kamal rollback <version>)
Secrets storeage-sealed secrets.age in the repo (default, no external service). provider: command runs any CLI (1Password op, Doppler, Vault, AWS Secrets Manager, Infisical CLI, Bitwarden)1Password / Bitwarden / LastPass / generic shell command
Accessory / app templatesyoink add postgres, yoink add openclaw, yoink add gh:owner/repo/path (yoink gets the template from GitHub, generates sealed secrets, and adds the fragment: a poor-man’s helm)First-class accessories: block
Resource limitsk8s-style ("500m", "2Gi")docker-style (cpus: 2, memory: 1g)
Per-service pids_limit✓✗
Secure-by-default RunOptions✓ (cap_drop=ALL, no-new-privileges, read_only=true, pids_limit=1024, init=tini, tmpfs noexec, binds default :ro)✗ (docker defaults)
Port-forward to non-published services✓ (yoink pf <svc>, auto-spawns socat sidecar, thus the locked-down “no publish:” default does not make debugging awkward)✗ (you bring your own ssh -L)
No-registry deploy✓ (yoink up --build ships any service with a build: block through an ephemeral unregistry sidecar. Only the missing layers go across the SSH wire, no registry account is necessary, and there is a tarball fallback)✗ (registry required)
Driven by AI agents / CI scripts✓ (CLI + YAML, identical local & remote)✓ (CLI + YAML)
MaturityNew (born 2026)Mature (born 2023, used at 37signals scale)
EcosystemRust-built, opinionated for “I run a few heterogeneous services”Ruby/Rails ecosystem, rails new → kamal init is the canonical Rails deploy story today

Kamal fits when: you have a Rails, Phoenix, or Hanami app, and you want one tool that builds, deploys, and routes. You do not need replicas or per-tier network isolation.

yoink fits when: you have several services with different shapes (Rust API + Node web + Postgres). You want drift detection, sealed in-repo secrets, and a k9s-style TUI for inspection and rollback. yoink also fits a hobby project that needs the standalone loop with no registry and no CI.

vs. Coolify

Coolify is a self-hosted PaaS, similar to an open-source Heroku or Render. It runs as a long-lived web app on one of your hosts. It manages build pipelines, databases, env vars, auto-deploys from git, and a UI for non-engineers. yoink is much narrower. It does the “deploy these containers to these hosts” part and has none of the PaaS surface area.

yoinkCoolify
ArchitectureSingle binary, runs on demandCoolify Core (web app + DB + queue) on one host, agent on each managed host
Operator interfaceCLI + TUI (keyboard-only)Web UI (primary), REST API (secondary)
State of truthThe yoink.yaml of the git repoThe database of Coolify (UI-edited, with an optional JSON export of environments + projects)
Build pipelinesOut of scope (use CI / yoink build)Built-in (Nixpacks, Dockerfile, buildpacks)
One-click databases (Postgres / MySQL / Mongo)Out of scopeBuilt-in templates with backups
Auto-deploy on git pushOut of scope (CI calls yoink up)Built-in (webhook + build)
Multi-user, RBAC, audit log◐ (audit log only, no users and no RBAC)✓
Bundled reverse proxy✓ (Caddy)✓ (Traefik)
Drift detection✓✗
Driven by AI agents / CI scripts✓ (all operations are CLI + YAML, no clicks required)◐ (REST API exists, but UI is the primary surface. Agents must learn the API and cannot only edit files)
Best fitEngineers who already have a CI + git workflow and want a thin deploy layerTeams who want a Heroku-shaped product and accept that they operate Coolify as a long-lived service

Coolify fits when: you want a batteries-included PaaS (build, deploy, database, web UI, multi-user). You also accept that you operate Coolify as a long-running service on one of your hosts.

yoink fits when: you already have CI and git for the build pipeline. You want the deploy layer to be a thin CLI that you run on demand. You prefer not to run one more web app and database to deploy your apps.

vs. Dokku

Dokku is the original “Heroku in a box”. A single host runs Dokku, and you git push dokku main. Then a buildpack or Dockerfile flow ships your app behind nginx with auto-TLS. Dokku needs little infrastructure and is opinionated about the “git push to deploy” loop.

yoinkDokku
ArchitectureSingle binary, runs on demandPer-host runtime (dokku on each host that it manages)
Number of hostsManyOne per Dokku install (no native multi-host)
Deploy triggeryoink up from your laptop or CIgit push dokku main
Image buildOptional (yoink build) or in CIBuilt-in (Buildpacks, Dockerfile, Lambda)
Bundled reverse proxy✓ (Caddy, ACME)✓ (nginx, Let’s Encrypt plugin)
Multiple services per host✓✓ (multiple “apps”)
Replicas✓✗ (one container per app process type)
Per-tier networks✓◐ (Dokku networks plugin)
Drift detection✓✗
Sealed in-repo secrets✓ (age)✗ (env vars set on the host)
Driven by AI agents / CI scripts✓ (CLI + YAML, identical local & remote)✓ (CLI on the host, SSH to operate remotely)
Best fitMulti-host fleets where the deploy tool is a thin clientSingle host that you SSH into, “git push to deploy” is the daily loop

Dokku fits when: one host is sufficient, the buildpack ergonomics fit your stack, and “git push to deploy” is the experience that you want.

yoink fits when: you want the same “add a config and run a command” simplicity, but across multiple hosts, with replicas, drift detection, and sealed in-repo secrets. You also prefer not to maintain a Dokku install on each host.

vs. Komodo

Komodo is also a Rust-built deploy and management tool for self-hosted containers, and it shares many features with yoink. The largest difference is ceremony. Komodo is a long-running web service with a control plane and per-host agents. yoink is a single binary that you run from your laptop or CI.

yoinkKomodo
ArchitectureSingle Rust binary, runs on demandKomodo Core (web service + UI) + Komodo Periphery (agent on each managed host)
Always-on services to operateNoneTwo: Core (with a database, MongoDB or FerretDB) + Periphery on each host
Operator interfaceCLI + TUI (k9s-style, keyboard-only)Web UI (primary) + CLI/API
State of truthThe yoink.yaml of the git repoThe database of Komodo (UI-edited, with optional GitOps “Resource Sync” file imports)
Deploy triggeryoink up from your laptop or CIClick in the UI, webhook, scheduled, or sync-from-git
Multi-user / RBACNone (operator-as-user)First-class users, groups, permissions
AuthThat which ssh + git + your secret store give youOAuth (GitHub / Google) + local accounts, built in
Bring-your-own-hostyoink connects to any host that you can ssh intoEach host needs Periphery installed + reachable from Core
Container shapeyoink-managed containers from a per-service specStacks (compose files) / Deployments / Builds / Repos
Drift detection✓ (yoink.spec_hash label)✓ (UI shows diff between desired and live)
Bundled reverse proxy✓ (Caddy)✗ (bring your own)
Healthcheck-gated rolling swap✓✓ (compose-style)
Audit log of who deployed whatJSONL audit log on each host (yoink audit log) + git history of yoink.yaml + per-container deploy labelsFirst-class audit log in the database
Driven by AI agents / CI scripts✓ (CLI + YAML, no GUI in the loop)◐ (API exists, but UI is the primary surface)
Best fit team size1 to 3 operators who share a repo3+ operators, a team that benefits from a UI + RBAC

Komodo fits when: you want a UI for people who do not use a CLI, you manage more hosts than one operator can remember, and RBAC matters. The control-plane functions must also be worth the overhead of a database, a web service, and per-host agents.

yoink fits when: a single binary on your laptop is the full control surface, and the git repo is the source of truth. You prefer not to operate one more service with a database. The CLI and TUI work best for 1 to 3 operators (or for AI agents and CI runners) who are comfortable in a terminal.

vs. Uncloud

Uncloud is for the same situation as yoink: a small fleet, multiple services, and deliberately not Kubernetes. The largest difference is again ceremony. Uncloud installs a daemon (uncloudd) on each managed host and connects the daemons into a WireGuard mesh. yoink is a one-binary client that talks to docker over plain ssh.

yoinkUncloud
ArchitectureSingle client binary that talks to docker on each host over sshPer-host daemon (uncloudd) on each managed host, peer-to-peer (no master)
Always-on services to operateNoneOne daemon per host (auto-installed by uncloud machine init)
Cross-host networkingNone. yoink relies on the per-host networks of docker, and cross-host is your routing decision (for example Tailscale or public DNS)First-class. Uncloud builds a WireGuard mesh between hosts, and services connect to each other by name across hosts
Reverse proxy / public ingress✓ (bundled Caddy with admin-API push, sealed certs, mTLS)First-class. Built-in Caddy-based ingress with auto-TLS
State of truthThe yoink.yaml of the git repoCluster state is in the daemon mesh. YAML config is also supported
Drift detection✓ (yoink.spec_hash label)✓ (compares running state to declared spec)
Multi-host service replicas✓ (per-host counts, services[].hosts: whitelist)✓ (cluster-aware scheduling)
Onboarding a new hostAlready works if you can ssh into ituncloud machine init to install + join the mesh
Driven by AI agents / CI scripts✓ (CLI + YAML, no daemon to coordinate with)✓ (CLI + YAML, daemon-aware)
What yoink leaves to other tools that Uncloud bundlescross-host service-to-service networkingn/a
Best fit“I have ssh access to my hosts and want a deploy tool that respects that”“I want a self-hosted lightweight cluster with mesh + ingress built in”

Uncloud fits when: cross-host service-to-service networking matters (your api on one host talks to your worker on a different host). You also accept a daemon on each host as the price of that function.

yoink fits when: you already have a routing answer (Tailscale, a single edge host, public DNS everywhere). You do not want an always-on yoink-specific service on the host, and the docker daemon over ssh is sufficient surface area.

The two tools agree on “small fleet of containers, opinionated defaults”. They disagree on whether the deploy tool also owns the network fabric.

vs. plain docker compose

Compose is a YAML schema that declares a stack on a single host. yoink is a deploy tool that runs against any number of hosts.

yoinkdocker compose
Multi-host✓✗ (one host, or you script around it)
Healthcheck-gated rolling swap✓✗ (docker compose up -d recreates without gating)
Per-service drift detection✓✗
Bundled reverse proxy with HTTPS✓ (Caddy + ACME / sealed certs)✗ (bring your own)
Secure-by-default container options✓✗ (the defaults of compose are dev-friendly: full caps, writable rootfs, no pids cap)
Port-forward to non-published services✓ (yoink pf <svc>, auto-spawns socat sidecar)✗ (bring your own docker exec / temporary ports: edit)
Pre-deploy hooks (for example migrations)✓ (hooks.pre_deploy)partial (depends_on + healthcheck workaround)
Secrets store✓ (age-sealed secrets.age in the repo by default, provider: command for any external CLI)✗ (env file or external)
TUI / drift dashboard✓✗
Driven by AI agents / CI scripts✓✓
Single binary, no Python/Compose runtime✓✗ (Compose v2 ships with docker, but still a separate runtime)

compose fits when: you have a local stack on a dev machine or a single-host hobby project, or you are already comfortable with deploy scripts around compose.

yoink fits when: you want the “declarative containers” model of compose with a real deploy story (rolling, multi-host, drift detection, secrets, hardened defaults, bundled proxy).

vs. Kubernetes

yoink is for people who do not want a control plane.

yoinkKubernetes
Control planeNoneetcd + apiserver + controller-manager + scheduler + kubelet on every node
Operator overheadSingle Rust binary on your laptopA team
Auto-scaling✗✓ (HPA / VPA / Cluster Autoscaler)
Multi-tenant / RBAC✗✓
Service mesh, ingress controllers, CSI, CNI plugins✗The whole ecosystem
Replicas + healthcheck-gated rolling swap✓✓ (Deployments)
Per-tier network isolation✓ (named docker networks)✓ (NetworkPolicy + CNI)
Resource limits (cpu/memory)✓✓
Secrets management✓ (age-sealed in-repo by default, provider: command to any external CLI)✓ (Secrets / external store)
Port-forward to non-published services✓ (yoink pf <svc>, auto-spawns socat sidecar)✓ (kubectl port-forward)
Driven by AI agents / CI scripts✓ (CLI + one YAML file)✓ (kubectl + many YAML files)
Imperative deploy commandyoink upkubectl apply -f

Kubernetes fits when: you have a real infrastructure team, you need autoscaling or multi-tenancy, or you operate across many regions. It also fits when your engineering org uses it as the standard, or when you want a service mesh.

yoink fits when: you want the Kubernetes ideas that give a benefit at small scale (drift detection, per-tier networks, healthcheck-gated rolls, declarative config, in-repo secrets), without the control plane and the team to operate it.

vs. nothing: just ssh + docker run

This is the baseline. Many small deployments are exactly this, and that is fine.

“Just ssh + docker run” fits when: you have one container, and you deploy only occasionally. You also accept that docker run does not roll, does not healthcheck, does not drain, and does not track who deployed what and when.

yoink fits when: you have shell scripts that wrap ssh + docker run, and you want to stop writing them. The yoink config has approximately the shape of those scripts, but it is declarative. yoink also gives you the rolling, healthcheck, drift, and history functions that you otherwise build yourself.

See also

  • What and why: the design philosophy on one page.
  • First deploy: a five-minute tutorial, if the matrix points you to yoink.
  • Architecture: drift detection, deploy lock, healthcheck-gated swap.
  • Example configs: complete yoink.yaml files for three kinds of deploy.

Type a flag, a config field, or a task.