Dokku

Dokku is a self-hosted Platform as a Service that brings the simplicity of Heroku’s git-push deployment workflow to a single server you control. It uses Docker to containerize applications and Heroku buildpacks to automatically detect and build them, so you can deploy Node.js, Python, Ruby, Go, Java, PHP, and dozens of other runtimes without writing Dockerfiles. A simple git push dokku main is all it takes to go from code to running container.

The architecture centers on a Unix-philosophy plugin system — every capability from SSL to databases to process scheduling is implemented as a discrete plugin. Core plugins ship with Dokku for git deployment, nginx reverse proxying, domain management, environment variable injection, and zero-downtime deployments. The community has built hundreds of additional plugins for PostgreSQL, Redis, MySQL, Elasticsearch, MongoDB, and more, making it possible to run a full production stack on a single $10 VPS.

Dokku has expanded well beyond its original single-server Docker model. It now supports multiple schedulers — Docker local, Kubernetes via k3s, Nomad, and a null scheduler for testing — allowing the same deployment interface to scale from a personal server to a multi-node cluster. Alternative reverse proxies including Traefik, Caddy, and HAProxy complement the default nginx setup. This flexibility has made Dokku a credible self-hosted alternative not just for individual developers but for small teams that need infrastructure control without Kubernetes complexity.

With over 31,000 GitHub stars, 317+ releases, and more than 13,000 commits since 2013, Dokku is one of the most mature and actively maintained self-hosted PaaS implementations available. It runs on Ubuntu 22.04/24.04 and Debian 11+ on both amd64 and arm64, installs in minutes via a single bootstrap script, and provides a complete application lifecycle management solution that includes building, deploying, scaling, logging, SSL, and domain routing.

What You Get

• Git-push Deployment - Push code to Dokku via git push dokku main and it automatically builds, containerizes, and deploys your application with zero additional tooling or configuration files required.
• Multi-Builder Support - Automatically detect and build applications using Heroku buildpacks (via herokuish), Nixpacks, Railpack, or raw Dockerfiles — covering Node.js, Python, Ruby, Go, Java, PHP, Scala, Clojure, and more without per-project build configuration.
• Zero-Downtime Deployments - Deploy new application versions without service interruption by hot-swapping the reverse proxy configuration to the new container only after health checks pass.
• Pluggable Proxy and Scheduler Backends - Swap the default nginx proxy for Traefik, Caddy, or HAProxy, and choose between Docker local, Kubernetes k3s, Nomad, or null schedulers — all without changing your deployment workflow.
• Built-in SSL via Let’s Encrypt - Automatically obtain and renew TLS certificates for your domains using the letsencrypt plugin, with support for both HTTP-01 and DNS-01 challenge modes.
• Environment Variable and Config Management - Inject application secrets and configuration via dokku config:set, with variables made available at both build time and runtime and persisted across deployments.
• Process Scaling and Procfile Support - Define multiple process types (web, worker, cron) in a Procfile and scale each independently with dokku ps:scale, with health check integration for reliable deployments.
• Extensible Plugin Ecosystem - Install official and community plugins to add PostgreSQL, Redis, MySQL, MongoDB, Elasticsearch, and hundreds of other services as linked data stores managed directly on the same server.

Common Use Cases

• Personal and side project hosting - A developer deploys multiple web applications on a single $10/month VPS using Dokku’s multi-app support and nginx virtual hosting, eliminating monthly SaaS PaaS fees entirely.
• Small team production infrastructure - A startup team of five deploys their Node.js API, Python worker, and React frontend via git push, using Dokku’s letsencrypt plugin for SSL and a linked PostgreSQL plugin for their database — all without a DevOps hire.
• Heroku migration and cost reduction - An organization running on Heroku migrates workloads to Dokku on a cloud VM, preserving their existing Procfile-based deployments and buildpack configurations while cutting infrastructure costs by 60-80%.
• CI/CD pipeline integration - A team uses git:from-image to deploy pre-built Docker images from their container registry, decoupling the build step from Dokku and enabling GitOps workflows where CI builds the image and Dokku handles deployment.
• Internal tools and microservices - A platform team uses Dokku with the k3s scheduler to host internal dashboards, webhooks, and APIs across a small Kubernetes cluster, using the same deployment interface as their development environments.
• Educational and learning environments - Computer science programs use Dokku to teach students containerized deployment concepts and DevOps workflows without the cost and complexity of managed cloud platforms.

Under The Hood

Architecture Dokku employs a highly modular, plugin-driven architecture grounded in Unix philosophy. The core is a Bash orchestrator that dynamically dispatches commands to plugin handlers through plugn, a convention-based plugin runner. Each plugin directory contains standardized hook files — install, commands, triggers — and can be implemented in any language, with newer plugins written in Go and legacy ones in Shell. Execution flows from SSH gateway through plugn trigger chains, where each plugin receives lifecycle events and responds independently. This event-driven hook system achieves loose coupling without explicit dependency injection frameworks — separation of concerns is enforced entirely by filesystem conventions and plugn’s discovery mechanism. The architecture is clearly layered: SSH command dispatch feeds plugn, which fans out to plugin hooks, which invoke schedulers (Docker, k3s, Nomad, null) and proxy engines (nginx, Traefik, Caddy, HAProxy). The scheduler abstraction is particularly elegant, allowing swappable deployment backends without altering the deployment interface or developer workflow.

Tech Stack The core CLI and critical plugins are implemented in Go organized as a Go workspace spanning over twenty plugin modules, while legacy and simpler plugins remain in Bash. Docker serves as the primary container runtime, with Docker Compose and containerd integration underpinning the local scheduler. The build pipeline supports multiple builders — herokuish for Heroku-compatible buildpacks, Nixpacks, Railpack, and raw Dockerfile — providing broad polyglot language coverage. Nginx is the default reverse proxy with Caddy, Traefik, and HAProxy as swappable alternatives. SSL automation uses certbot via a dedicated letsencrypt plugin. Testing infrastructure uses BATS for integration tests against dozens of real application stacks across multiple language runtimes. Build tooling uses GNU Make with separate makefiles for arch packaging, Debian packaging, documentation, and test orchestration. Documentation is built with MkDocs using the Material theme with comprehensive search.

Code Quality Testing is comprehensive at the integration level — the tests directory contains extensive real application stacks used as end-to-end deployment subjects across Node.js, Python Flask, Go, Ruby, Clojure, Scala, Dockerfile, and Procfile variants. BATS scripts cover individual plugin behaviors including checks, health validation, proxy configuration, builder detection, and process management. Go code includes unit tests with gomega assertion patterns. Error handling in shell code uses set -eo pipefail consistently with explicit exit code validation and structured cleanup via trap. Go code uses typed errors with idiomatic propagation. Naming is consistent throughout — plugins use hyphenated slugs matching their filesystem paths, Go functions follow camelCase, and shell functions use declare desc= documentation conventions. CI via GitHub Actions covers shellcheck linting for shell scripts, staticcheck for Go, automated test runs against multiple Ubuntu versions, and dependency updates via Dependabot with high cadence.

What Makes It Unique Dokku’s defining innovation is compressing the complete Heroku PaaS experience — git push deployment, automatic language detection, reverse proxy routing, process scaling, SSL certificate management — into a single-server tool maintainable by one person. The plugn hook system allows arbitrary language extensions without core modifications, enabling an ecosystem of hundreds of community plugins that can be installed and configured without forking. The multi-scheduler abstraction using the same deployment interface from a $5 VPS all the way to a Kubernetes k3s cluster is genuinely rare among self-hosted PaaS tools. The git-from-image and git-from-archive deployment methods extend beyond traditional source-based git push, enabling container-native CI/CD workflows where builds happen in pipelines and Dokku handles deployment exclusively, supporting modern GitOps patterns without compromising the simplicity that defines the project.

Self-Hosting

Dokku is released under the MIT License, one of the most permissive open source licenses available. This means you can use it commercially, modify the source, distribute it, and build proprietary systems on top of it without any obligation to release your changes. There are no copyleft requirements — your application code and infrastructure configuration remain entirely your own. The only constraint is retaining the copyright notice in copies of the software itself.

Running Dokku yourself requires a Linux server (Ubuntu 22.04/24.04 or Debian 11+ on amd64 or arm64) with root access and Docker. Installation is a two-command process via the bootstrap script. From there, you are responsible for all operational concerns: server uptime, OS patching, Docker upgrades, Dokku upgrades (which follow a documented upgrade path between versions), disk space management, database backups via plugin tooling, and network security configuration including firewall rules and SSH key management. Single-server deployments have no built-in high availability — a server failure takes down all hosted applications. The k3s scheduler plugin extends Dokku to multi-node Kubernetes deployments, but configuring and maintaining k3s adds substantial operational complexity.

Dokku Pro is a separate commercial offering that adds a web UI, JSON API, and HTTPS-based git push as alternatives to the CLI. It requires a purchased license key and internet connectivity for license validation at startup (offline enterprise licensing is available on inquiry). Compared to managed PaaS platforms like Heroku or Render, self-hosting Dokku means you handle everything that those platforms abstract away — infrastructure provisioning, SSL renewal failures, container restart policies, log retention, and incident response. What you gain is complete data sovereignty, no per-dyno pricing, and the ability to run any workload without platform-imposed restrictions on memory, CPU, process count, or network configuration.