Dokku is an open-source, self-hosted PaaS that enables developers to deploy, scale, and manage applications using Docker and Heroku-compatible buildpacks. It’s designed for individuals and small teams who want the simplicity of Heroku without vendor lock-in, running on a single server with minimal overhead. By leveraging Docker containers and nginx routing, Dokku automates application lifecycle management from git push to live deployment.
Built as a collection of modular plugins, Dokku integrates with existing DevOps tooling like SSH, Git, and systemd. It supports Ubuntu 22.04/24.04 and Debian 11+ on AMD64 and arm64 architectures, and can be installed via a single bootstrap script. Deployment is handled through Git, with automatic build detection, container orchestration, and domain routing—all without requiring Kubernetes or complex orchestration layers.
What You Get
- Git-based Deployment - Push applications to Dokku via
git push dokku main; it automatically detects language via Heroku buildpacks or uses a Dockerfile to build and deploy containers.
- Heroku Buildpack Support - Automatically detects and builds apps using Heroku buildpacks for Node.js, Python, Ruby, PHP, Java, and more without requiring Dockerfiles.
- Docker Container Orchestration - Each app runs in isolated Docker containers with automatic port mapping, environment variable injection, and process management via systemd.
- Built-in Domain Management - Configure global or per-app domains using
dokku domains:set-global and route traffic via nginx with support for wildcard domains like *.yourdomain.com.
- SSH Key Authentication for Deployment - Securely authenticate git pushes using SSH keys managed via
dokku ssh-keys:add without requiring API tokens or webhooks.
- Extensible Plugin System - Extend functionality with plugins written in any language; official plugins add support for PostgreSQL, Redis, MySQL, Let’s Encrypt SSL, and more.
Common Use Cases
- Running a personal blog or portfolio site - A developer deploys a static site or Node.js blog via
git push using Dokku’s buildpack detection, avoiding monthly SaaS fees.
- Hosting internal tools and microservices - A small team deploys custom Python or Go services on a $5/month VPS using Dokku’s lightweight container model instead of Kubernetes.
- Deploying side projects with zero cloud vendor lock-in - A freelancer uses Dokku on a DigitalOcean droplet to host apps without relying on Heroku’s pricing or uptime guarantees.
- Educational environments for learning PaaS concepts - A university lab uses Dokku to teach containerization and deployment pipelines without requiring complex orchestration tools.
Under The Hood
Architecture
- Modular plugin system using shell-based scripts with clear separation between core and extensible functionality via plugn and file system conventions
- Command-line interface dynamically loads plugins through convention-over-configuration patterns, enabling extensibility without recompilation
- Dependency injection achieved through environment variables and configuration files, adhering to Unix philosophy of composable tools
- Build and deployment pipeline layered into build (herokuish, nixpacks), runtime (Docker), and deployment (sigil) components with well-defined boundaries
- Plugin lifecycle and command registration enforced via strict directory structures and file system semantics, enhancing transparency and debuggability
- Unified build process using Go and Makefiles to compile both core and plugins into native binaries with cross-platform support
Tech Stack
- Go-based core application with plugins implemented as shell scripts, leveraging static analysis tools for code quality
- Docker-centric infrastructure using lightweight base images and containerd for reproducible, isolated application environments
- Herokuish as the primary buildpack execution engine, extended with Nixpacks and Railpack for multi-language build support
- Plugin execution managed through plugn and sshcommand, enabling secure, isolated command execution
- Build and packaging automated via Makefiles with Debian package generation and JSON-configured dependency resolution
- Documentation system powered by MkDocs with Material theme and embedded search for intuitive user guidance
Code Quality
- Extensive end-to-end testing using BATS scripts to validate real-world deployment scenarios, including proxy configuration and buildpack behavior
- Test environments isolated through structured setup and teardown functions, ensuring consistent and reproducible results
- Robust error handling via exit code validation and output inspection, aligning with shell-based tooling paradigms
- Consistent naming conventions across plugins and tests, using descriptive hyphen-separated identifiers for clarity
- Strong structure enforced through explicit file permissions, environment validation, and structured configuration formats
- Comprehensive linting and validation integrated into CI pipelines to verify configuration rendering, network behavior, and failure modes
What Makes It Unique
- Uses Docker as a lightweight PaaS abstraction, enabling single-command deployments without orchestration complexity
- Plugin-driven architecture with shell hooks allows deep customization without touching core code, fostering community extensibility
- Built-in automated SSL and domain management via Let’s Encrypt triggered directly from git pushes
- Zero-downtime deployments achieved through reverse proxy reconfiguration rather than container restarts
- Git-push-to-deploy workflow unifies development and operations, making deployment feel like a natural extension of coding
- Intelligent buildpack detection with Dockerfile fallback reduces configuration overhead while preserving flexibility