/dev/push is an open-source, self-hosted platform that automates the deployment of web applications built with Python (Django, Flask, FastAPI), Node.js, PHP, and any Docker-compatible runtime. It eliminates the need for third-party hosting services by providing a Vercel-like experience on your own server, handling builds, DNS, SSL, and environment management through Git pushes. Ideal for developers and teams seeking full control over their deployment infrastructure without vendor lock-in.
Built with FastAPI, HTMX, and Basecoat, /dev/push uses Docker Compose, Traefik, and PostgreSQL to orchestrate deployments. It integrates with GitHub for authentication and webhooks, automatically provisions Let’s Encrypt SSL certificates, and supports custom domains and environment variables. Deployment is streamlined via a single install script on Ubuntu/Debian servers, with full Docker-based isolation for each project.
What You Get
- Git-based deployments - Automatically build and deploy apps on git push to GitHub, with zero-downtime rollouts and instant rollback via Docker containers.
- Multi-language support - Deploy Python (Django, Flask, FastAPI), Node.js, PHP, and any application that runs in a Docker container without language-specific configuration.
- Environment management - Create multiple environments (production, staging) with branch-to-environment mapping and encrypted environment variables via Fernet encryption.
- Real-time build and runtime logs - View live, searchable logs during build and app startup, including package installation output and Gunicorn worker logs.
- Team collaboration with RBAC - Invite team members with role-based permissions (Owner, Admin) and manage access via GitHub OAuth integration.
- Custom domains with automatic SSL - Configure custom domains and deploy subdomains (e.g., myapp.deploy.example.com) with automatic Let’s Encrypt certificate issuance via ACME challenges.
- Self-hosted and MIT licensed - Run entirely on your own Ubuntu/Debian server with no SaaS dependency; source code is fully open and modifiable.
- Docker-based deployment engine - Each app runs in an isolated Docker container with custom build and start commands defined per project, orchestrated by Docker CLI and Traefik.
Common Use Cases
- Running a Python web app with zero-downtime deploys - A developer uses /dev/push to deploy a Flask or FastAPI API to their own server, ensuring no downtime during code updates and automatic rollback on failures.
- Hosting multiple client projects with isolated environments - A freelance developer deploys Django apps for different clients on the same server, each with its own domain, environment variables, and access controls.
- Team-based deployment for internal tools - A startup team collaborates on a Node.js dashboard, using /dev/push to manage staging and production environments with GitHub-based access control and real-time logs.
- Replacing Vercel for non-JavaScript projects - A Python-focused team migrates from Vercel to /dev/push to deploy Django and FastAPI apps with the same Git-push workflow, avoiding JavaScript tooling complexity.
Under The Hood
Architecture
- FastAPI-based API layer with dependency injection that cleanly separates routing, data fetching, and business logic
- Event-driven architecture using Server-Sent Events and Redis pub/sub to decouple log ingestion from real-time client streaming
- Server-side rendered UI with Jinja2 templates, HTMX partial updates, and reusable macros enabling interactive experiences without client-side frameworks
- Alembic-managed database migrations with ORM models that encapsulate domain entities and their relationships
- Modular directory structure organizing templates, routers, and models, though dependency injection lacks a formal service container
Tech Stack
- Python backend powered by FastAPI with Pydantic for validation and Starlette for ASGI handling
- SQLAlchemy and Alembic for ORM-based data operations and schema evolution
- Redis integrated with ARQ for asynchronous task queuing and caching
- WTForms and Starlette-WTF for server-side form validation and handling
- Jinja2 templating for dynamic HTML rendering with consistent layout patterns
Code Quality
- Limited testing practices with no structured test cases, leaving critical services like Loki integration unverified
- Inconsistent error handling with generic try/catch blocks and no custom exceptions, resulting in opaque failure modes
- Type safety is inconsistently enforced, particularly in log parsing and API payloads where hints exist but are not utilized
- Naming conventions vary across modules, with some components using descriptive names while others rely on vague terms like ‘service’ or ‘utils’
- Absence of linting or formatting tooling leads to unstandardized code style and reduced maintainability
- Frontend templates implement reactive patterns but lack state management and accessibility considerations
What Makes It Unique
- Dynamic project preset detection that auto-configures build and deploy workflows based on codebase structure and dependencies
- Unified logging architecture with Loki that correlates logs across environments and branches using structured metadata
- Real-time deployment status streaming via Redis streams with granular event broadcasting, enabling live dashboards without polling
- Registry-based runner and preset catalog with JSON schema validation and runtime overrides for extensible, version-controlled templates
- Intelligent subdomain routing that auto-generates clean, semantic URLs tied to project and branch semantics
- Server-rendered UI with HTMX and Alpine.js that delivers rich interactivity without the complexity of full SPAs