/dev/push

/dev/push is an open-source, self-hostable deployment platform that brings Vercel-like Git-push workflows to any language or runtime. Rather than being locked into a specific cloud provider or language ecosystem, teams can run /dev/push on their own Ubuntu or Debian servers and deploy Python (Django, Flask, FastAPI), Node.js, PHP, and any Docker-compatible application using the same familiar git push workflow.

At its core, /dev/push combines FastAPI, Docker Compose, Traefik, PostgreSQL, Redis, and Loki into a cohesive deployment orchestration system. When code lands on a branch, GitHub webhooks trigger the deployment pipeline: a language-specific runner container is provisioned, the repository is cloned, build commands are executed, and the app starts — all with zero-downtime handoff between old and new containers. Traefik handles reverse proxying and automatic SSL via Let’s Encrypt, while Loki and Grafana Alloy power centralized, searchable log streaming.

For teams managing multiple projects or clients, /dev/push provides multi-environment support (production, staging, and custom environments), branch-to-environment mapping, encrypted environment variables via Fernet, and role-based access control with GitHub OAuth integration. Each project gets its own subdomain and optionally a custom domain, with aliases updated automatically on every successful deployment.

Unlike generic container orchestrators, /dev/push includes a smart preset detection system that inspects repository file patterns and package manifests to auto-configure build and start commands for known frameworks — reducing setup friction for common stacks like Django, FastAPI, Next.js, Laravel, and Drupal.

What You Get

• Git-based zero-downtime deployments - Push a branch and /dev/push automatically provisions a runner container, runs your build commands, waits for the app to become healthy, then switches traffic with no downtime and instant rollback capability.
• Multi-language runtime support - Deploy Python (Django, Flask, FastAPI, Gunicorn), Node.js, PHP (Laravel, Drupal via FrankenPHP), and any application that runs in Docker without language-specific configuration overhead.
• Smart preset auto-detection - The platform inspects repository file patterns and package manifests to automatically configure build and start commands for known frameworks, reducing manual setup for teams using Django, FastAPI, Next.js, Laravel, and others.
• Multi-environment project management - Create production, staging, and custom environments with branch-to-environment mapping; each environment gets its own subdomain alias and isolated encrypted environment variables.
• Real-time searchable log streaming - Build and runtime logs are collected by Grafana Alloy, stored in Loki, and streamed live to the browser via Server-Sent Events — fully searchable by keyword, environment, branch, or deployment ID.
• Team access control with GitHub OAuth - Invite teammates with Owner or Admin roles; authentication is handled through a GitHub App you control, so access management ties directly to your existing GitHub organization.
• Custom domains with automatic SSL - Assign custom domains to any project environment; Traefik handles certificate issuance and renewal via Let’s Encrypt using HTTP-01 or DNS-01 (Cloudflare, Route53, GCloud, DigitalOcean, Azure) challenge providers.
• Fernet-encrypted environment variables - Project environment variables and OAuth tokens are encrypted at rest using Fernet symmetric encryption, with secrets injected into runner containers at deploy time without being logged.

Common Use Cases

• Replacing Vercel for polyglot teams - A team running Python APIs alongside Node.js front-ends migrates to /dev/push to get the same Git-push deployment experience across all languages on their own server, eliminating per-function pricing and language restrictions.
• Multi-client project hosting for agencies - A freelance developer or small agency hosts Django and Laravel projects for multiple clients on a single Hetzner server, with each client’s projects isolated by team, custom domain, and environment-scoped secrets.
• Staging environments tied to pull requests - Developers configure branch-to-environment mapping so every feature branch automatically deploys to a staging subdomain (e.g., myapp-branch-feature-auth.deploy.example.com), enabling QA review before merging.
• Internal tooling with controlled access - A startup deploys internal dashboards and admin panels using /dev/push’s GitHub OAuth, so only team members with repository access can log in — no separate user management system required.
• Cost-conscious startups self-hosting on Hetzner - Early-stage teams provision a single Hetzner CPX31 (~€13/month) and run all their applications through /dev/push rather than paying per-deployment or per-seat on managed PaaS providers.

Under The Hood

Architecture /dev/push follows a clean event-driven architecture where the FastAPI web layer, background worker pool, and container monitoring process communicate exclusively through Redis — the app enqueues deployment jobs, ARQ workers consume them, and a separate monitor process polls running containers to trigger finalization or failure handling. Traefik acts as the single ingress layer for both the platform itself and all deployed user applications, with dynamic configuration files written per-project to manage aliases, branch URLs, and custom domains. This separation of concerns between request handling, async work, and reverse proxy configuration means each layer can scale or fail independently, with no shared mutable state between the app and workers beyond Redis streams.

Tech Stack The platform is built on Python 3.13 with FastAPI and Starlette for the async web layer, SQLAlchemy (async) with Alembic migrations for PostgreSQL access, and ARQ on Redis for the background job queue. Runner containers are managed via aiodocker (async Docker SDK), while Traefik handles ingress with Docker-provider labels and file-provider dynamic config for aliases. The frontend uses server-side Jinja2 templates enhanced with HTMX for partial page updates and Alpine.js for lightweight interactivity, styled via Basecoat — avoiding the complexity of a client-side framework while delivering real-time UI updates through SSE endpoints. Log infrastructure relies on Grafana Alloy tailing container log files and shipping to Loki, which the app queries directly via LogQL for deployment log streaming.

Code Quality The codebase has no automated test suite — no pytest files, no unit or integration tests exist anywhere in the repository. Error handling is functional but inconsistently applied: some services use structured logging with explicit exception types while others swallow exceptions with broad try/except blocks, particularly in the Loki integration and Docker API calls. Type annotations are present throughout models and service methods, but some utility functions and template helpers lack coverage. The project uses uv for dependency management and ships a well-structured pyproject.toml, though no linter or formatter configuration (ruff, black, mypy) is included. Despite the absence of formal testing infrastructure, the codebase is logically organized with clear boundaries between routers, services, and worker tasks.

What Makes It Unique The preset detection system stands out as a genuinely novel contribution: rather than requiring manual framework configuration, /dev/push fetches the full git tree via GitHub’s API and pattern-matches against a versioned JSON registry catalog of runners and presets — including variant detection that can differentiate a pure Laravel project from one that also requires Node.js (switching between frankenphp-8.3 and frankenphp-node-8.3 runners automatically). The unified Loki-backed log architecture labels every log entry with project, deployment, environment, and branch metadata, enabling cross-environment log correlation that most self-hosted deployment tools do not provide. Combined with instant-rollback via Traefik alias file regeneration and encrypted-at-rest environment variable snapshots per deployment, /dev/push delivers a level of deployment safety and observability rarely found in open-source PaaS alternatives.

Self-Hosting

The MIT License governs /dev/push, which means you can use it commercially, modify the source code, distribute it, and integrate it into proprietary systems without any obligation to open-source your own code. There are no copyleft implications — you own your deployment, your data, and any modifications you make. The project is maintained by a solo author (Ronan Berder) with a small number of contributors, so the MIT license reflects a community-first philosophy rather than an open-core model.

Running /dev/push yourself requires a Linux server (Ubuntu 20.04+ or Debian 11+ with sudo access), Docker and Docker Compose v2+, a GitHub App for authentication and webhook delivery, and either a Resend account or SMTP credentials for email. The installation is a single curl script that sets up systemd, Docker, Traefik, PostgreSQL, Redis, Loki, and Alloy. Operationally, you are fully responsible for server uptime, disk space management (logs, container images, volumes), SSL certificate renewal (handled automatically by Traefik), and database backups (a backup.sh script is included). Horizontal scaling of the app and worker services is architecturally supported but requires manual orchestration — there is no built-in clustering or managed failover.

There is no hosted SaaS offering or paid cloud tier for /dev/push as of early 2026 — the project is entirely self-hosted. This means you gain complete data sovereignty and avoid per-seat or per-deployment pricing, but you give up managed uptime SLAs, automated off-site backups, professional support channels, and the convenience of a managed control plane. The project is actively maintained with frequent releases, but as a solo-maintained open-source tool, you should plan for hands-on operations and budget time for upgrades (via the included update.sh script) when new releases ship.