Git repositories
Connect GitHub or your self-hosted Git server. Pushing code triggers a webhook, our build system detects your framework, and your container deploys instantly to your project network.
Branch previews · main to production
App deployment
Five deployment paths.One unified model.
Whichever deployment path you choose, the end result is identical: an isolated container running inside your private project network with storage volumes, custom domains, secrets, and team access ready to go.
Project workflow01 / 03
01
SourceGit push to deploy
02
ControlAuto-detected runtimes
03
ReleaseScale to zero
Hubfly space projectNetwork · volumes · domains · team access
One project model
Deployment sources
Deploy code from where you already work.
Whether you're pushing images from CI/CD pipelines, prototyping from a local Git branch, or launching pre-wired services from templates, every path lands cleanly into the same project model.
Docker and OCI images
Deploy pre-built containers directly from Docker Hub, GitHub Container Registry (GHCR), Quay, or private registries using secure encrypted credentials.
Public or private registries
Pre-built templates
Spin up popular services in one click from our template catalog — including Postgres, Redis, MongoDB, Nginx, FastAPI, and Go Gin with production-ready defaults.
One-click provisioning
Custom Dockerfiles
Point us to a Dockerfile anywhere in your repository. When a Dockerfile is present, it automatically takes precedence over our framework auto-detection.
Root or subfolder context
CLI upload
Package and ship your local project directory straight from your machine without making a git commit — perfect for quick testing and private code.
hubfly deploy
Zero-config builds
Smart build detection for your code.
Hubfly space inspects your repo's manifest files to automatically select the right runtime, build the container image, and validate build commands before execution.
RuntimeDetected fromBase imageDefault start
Bun
Detected from
bun.lock
Base image
oven/bun:1.2
Default start
bun run index.ts
Node.js
Detected from
package.json
Base image
node:18-alpine
Default start
npm install && npm start
Go
Detected from
go.mod
Base image
golang:1.18-alpine
Default start
Multi-stage build → binary
Python
Detected from
requirements.txt · pyproject.toml
Base image
python:3.14.4-slim
Default start
pip install -r requirements.txt
Java
Detected from
pom.xml · build.gradle
Base image
Maven / Gradle JDK17
Default start
mvn clean package
PHP
Detected from
composer.json
Base image
php:8.3-apache
Default start
Apache / FPM init
Static
Detected from
index.html
Base image
nginx:alpine
Default start
Nginx web server
Note: Including a Dockerfile in your repo always overrides framework auto-detection.
Layer caching
Unchanged build layers are cached and reused across builds for fast deploys.
Command allowlisting
Auto-generated build steps are verified against platform security allowlists.
Vulnerability scanning
Trivy and Govulncheck inspect every built image for known vulnerabilities.
Container tiers
Choose when your containers sleep.
Sleepable compute is your biggest cost lever. Keep resources always-on for critical production APIs, and let staging or side-project containers pause when nobody is using them.
01
Shared Compute
shared
Can scale to zero
Development, staging, low-traffic sites, lightweight APIs
02
Dedicated Sleepable
dedicated_sleepable
Can scale to zero
Internal team tools with predictable working hours
03
Dedicated 24×7
dedicated_24x7
Always available
Production APIs, databases, and WebSocket services
04
Auto-Scaling
auto_scaling
Always available
Spiky load needing live CPU, RAM, and disk growth
05
Docker-OS
docker-os
Always available
Full Linux environments with systemd and system access
Sleeps when idle
Our scheduler tracks incoming connections. After an idle window (15 minutes by default), your container pauses to free up CPU and memory.
Wakes instantly on request
When a new request hits our edge proxy, it holds the HTTP connection while signaling the container cell to wake up. Visitors notice a tiny delay, never an error.
Resizes without restarts
On auto-scaling tiers, cgroup memory limits increase dynamically and rootfs storage expands live using `resize2fs` without taking your app offline.
Supervised process restarts
Long-running services are automatically restarted if they crash according to your supervisor policies. One-off batch jobs complete and gracefully exit.
Compose stacks
Multi-service apps running in harmony.
Import an existing `docker-compose.yml` or build multi-container stacks in the UI. Services communicate securely on your private network and start up in the exact order required.
Dependency ordering
Supports `depends_on` conditions natively: wait for a database service to start, pass its healthcheck, or for a setup job to complete successfully.
service_healthy · service_completed_successfully
Git sync for stacks
Link your stack to a `docker-compose.yml` in your repository to automatically update and redeploy all stack services whenever you push code changes.
Versioned stack definitions
Stack configurations are stored as clean JSON or YAML definitions that you can edit, version control, and re-apply reliably across environments.
Full CLI control
Inspect, test, bring up, or tear down your multi-container stacks directly from your terminal using simple CLI commands.
hubfly stack up · status · down
Dependency resolution
docker-compose.yml
postgres
waits for healthcheck
healthy
migrate
job completes successfully
exited 0
api
postgres and migrate ready
running
worker
api is available
running
Project private network
Four services · 10.30.1.0/24
From the terminal
Ship deploys directly from your terminal.
The Hubfly space CLI packages code locally, streams the build to the regional builder, and binds redeploys cleanly to live services using `hubfly.build.json`.
Built for CI and local automation
Every interactive prompt has a corresponding CLI flag, making commands easy to script in CI pipelines.
Explainable build configuration
`hubfly.build.json` locks build settings while `hubfly build explain` previews steps before running.
Bound redeploys
Subsequent deploys seamlessly replace live container instances without creating orphan services.
hubfly-cli
$ hubfly deploy --project edge-api --region eu-west-1 --yes
Detected runtime: Bun (bun.lock)
Building image locally from ./hubfly.build.json
Uploading image to the regional builder
Deployment succeeded · bound container updated
$ hubfly stack up
Parsing docker-compose.yml · 3 services
Waiting on postgres (service_healthy)
Started api, worker · private network 10.30.1.0/24
Ship it
Connect your repository and deploy today.
Our free shared tier includes 360 runtime hours each month. Containers pause when idle so you're never charged for waiting.