Daemonless container cells
Your code runs as a plain Linux process under cgroups v2 with an ext4 rootfs. There's no heavy Docker daemon sitting between you and the kernel.
hubcell runtime
Platform overview
Deployments, isolated networking, persistent storage, image registries, team access control, and billing aren't separate tools stitched together. They operate seamlessly inside a single project boundary.

01
9
Integrated components
Dashboard, runtime, CLI, builder, proxy, scheduler, files, SDKs, dev kit
02
5
Deployment sources
Git, OCI image, template, Dockerfile, CLI upload
03
2 min
Metering granularity
Usage buckets across compute, memory, storage, and GPU
04
7
Linux namespaces per cell
PID, mount, net, UTS, IPC, user, and cgroup isolation
Compute
Compute engineered for efficiency — automatic scale-to-zero, live resource resizing, and supervised process restarts without an underlying daemon.
Your code runs as a plain Linux process under cgroups v2 with an ext4 rootfs. There's no heavy Docker daemon sitting between you and the kernel.
hubcell runtime
Containers pause when traffic stops, dropping CPU and RAM usage to zero. When a new request arrives, our edge holds it briefly while the cell wakes right back up.
Default 15 min idle
Bump memory limits on the fly via cgroup v2 without restarting, and let your rootfs grow seamlessly in place with resize2fs while the cell is live.
No redeploy
Keep long-running services alive with supervised automatic restarts. For database migrations or batch scripts, run them as one-off jobs that clean up when done.
Jump into a real PTY terminal inside your live container over WebSocket, trigger quick one-line commands, or stream stdout and stderr live to your console.
hubfly ssh · logs -f
Secret variables are encrypted with AES-256-GCM using unique nonces and versioned keys. They stay encrypted until decrypted in-memory right at boot.
Networking
Containers within a project communicate over an isolated network. Public access, custom domains, TLS certificates, and load balancing are explicit choices.
Containers inside a project talk securely over an isolated internal network. Nothing touches the public internet until you explicitly open a port.
Verify your domain with a quick DNS record or HTTP check. We handle issuing Let's Encrypt certificates and auto-renewing them 30 days before they expire.
Wildcards via ACME DNS-01
Distribute incoming traffic using round-robin, least-connections, or IP-hash routing, complete with weighted target distribution for seamless canary deploys.
Set custom probe paths and test intervals. If a container stops responding healthily, it gets pulled from the load balancer pool automatically.
Reserve dedicated public host ports for non-HTTP workloads like Postgres, Redis, gRPC endpoints, or multiplayer game servers.
Connect directly to private containers from your local machine over an encrypted WebSocket tunnel handling up to 64 multiplexed streams — no public port needed.
hubfly tunnel
Edge
Caching, firewall protection, rate limiting, and request tracing run right at the regional edge ingress so protection is built-in.
Our edge proxy serves instant cached responses to users while silently revalidating in the background. Instant cache purges work across site, path, or domain.
Protect your apps with IP allow/deny lists, request rate limits, bot filtering, and circuit breakers that cleanly throw 503s before failures cascade.
Every single response includes a unique request ID and Server-Timing metadata, giving you total visibility into backend latency and proxy overhead.
X-HubProxy-Request-Id
Managed Databases
Pick an engine and a size, decide who can connect, and bind the database to your apps. Hubfly space provisions and runs the instance in a location it chooses.
Run PostgreSQL 18, 17 or 16, MySQL 8.4 or 9.7 LTS, or SQLite served over HTTPS by libSQL, each on its own dedicated CPU, memory and storage.
Nano to X-Large or custom
Connections always use TLS. Download the instance certificate to verify the server, limit public access to up to 64 address ranges, or turn it off.
Bind a database to a Cell project and Hubfly space writes DATABASE_URL, or LIBSQL_URL and LIBSQL_AUTH_TOKEN, into its environment, optionally with its own user.
Create databases and users with read-only, read-write or admin access, issue libSQL tokens, and install PostgreSQL extensions such as pgvector and PostGIS.
Query from the browser in an editor that stays read-only until you allow writes, or open a shell with hubfly db shell.
Follow CPU, memory, storage and connections, read logs, cancel or end sessions, see the slowest queries, and change engine settings with validation.
Realtime
A dedicated WebSocket server for chat, notifications, live dashboards and presence, with Hubfly space extensions for direct messages, history and end-to-end encryption. Realtime is rolling out gradually.
Public, private, presence, encrypted and cache channels, client events and the signed server API work with pusher-js, Laravel Echo and Pusher server libraries.
Protocol 7
You generate and keep the master keys. Hubfly space checks that encrypted messages are well formed but never receives the keys, so it cannot read their content.
Send to one connection or to every connection of a user, queue messages for offline users and receive delivery receipts with @hubfly/realtime.
Keep recent messages per channel in memory or durably, with a time limit and maximum count you set per app, so clients can catch up after reconnecting.
Receive channel, presence and connection events at your HTTPS endpoint, with a delivery log, test sends and redelivery.
Each app has its own keys, allowed origins, limits and webhooks. Rotate keys with a grace period, and restart the server without dropping connections.
Managed Streams
Live video and audio servers that take any encoder, mix sources in a studio, and spread the result to your own player and every platform at once. You pay for the speed you reserve and the bandwidth you send.
Publish over RTMP, RTMPS, SRT, WHIP from a browser, or Icecast for radio, or pull an RTMP, RTSP, SRT or HLS source, with a backup key that takes over automatically.
RTMP · SRT · WHIP · Icecast
Push a channel to YouTube, Twitch, Facebook, Kick, X, LinkedIn and any RTMP(S) or SRT target at once, starting automatically when you go live.
WebRTC under a second, LL-HLS in 3–5 seconds and HLS for everyone else, with an embeddable player that picks the best one on its own.
WHEP · LL-HLS · HLS
Scenes, picture-in-picture and grids, graphics with live variables, audio mixing and transitions, driven from the browser, the API or a schedule.
Start shows, destinations and recordings on a timetable in your time zone, and loop Hubfly space Storage videos into channels that never stop.
Token-protected channels signed on your backend, allowed origins and viewer limits, and signed webhooks for live, offline and recording events.
Volumes and registry
Managed persistent volumes for stateful applications paired with an isolated per-project image registry that scans code on push.
Attach high-speed block storage anywhere in your container's filesystem. Volumes easily survive restarts, updates, and reattaching across containers.
Pick between standard, balanced, or high-performance IOPS options to match whether you're serving static assets or handling heavy DB writes.
Backup your persistent data automatically by piping encrypted volume snapshots directly to your own S3-compatible storage on a set schedule.
Every project gets its own private, isolated OCI registry namespace. Version-tag and store images generated from our builder or your custom CI pipeline.
Trivy and Govulncheck inspect every image push automatically, flagging affected packages, installed versions, and exact patch releases.
Critical → Low severity
Generate pull-only, push-only, or full-access API tokens for external CI/CD systems, along with short-lived pre-signed download links.
Developer tools
Deploy apps, create databases, realtime servers and buckets, establish local tunnels, and stream live logs directly from your command line or code using our SDKs.
Manage workloads right from your terminal with a clean Go CLI. Explore projects, track live container stats, launch SSH shells, and manage active tunnels.
hubfly projects
Our build system auto-detects Node, Bun, Go, Python, Java, PHP, and static projects straight from manifest files — or defaults to your custom Dockerfile.
Spin up multi-container applications using standard `docker-compose.yml` files, respecting start dependencies and health check conditions.
depends_on conditions
Trigger automated deployments from external systems using secret webhook URLs protected with HMAC-SHA256 signatures and IP filtering.
Programmatically deploy apps, inspect project states, configure custom domain routing, and manage active tunnels using native TypeScript and Go SDKs.
Browse, edit, upload, download, and compress files directly inside your persistent volumes from the dashboard using scoped sharing sessions.
Create, resize and bind managed databases, run SQL, manage users, and export or import data with the hubfly db commands.
hubfly db
Create realtime servers, manage apps, keys and webhooks, publish test events, and tail live traffic with hubfly realtime.
hubfly realtime
Create stream servers, inputs, channels and destinations, switch scenes, watch live health, and push a file or camera with hubfly stream.
hubfly stream
Create buckets, upload and download objects, issue scoped S3 keys straight into an app's environment, and publish assets with hubfly storage.
hubfly storage
Teams and governance
Granular role-based access, scoped API tokens, detailed audit trails, spending caps, and kernel-level tenant isolation for growing teams.
Assign clear permissions — Owner, Admin, Developer, Operator, Billing, or Viewer — ensuring team members only access what they need.
Track sensitive org operations with rich audit trails recording the user, target resource, IP address, user agent, and API request ID.
Issue granular access tokens scoped strictly to specific project IDs so a leaked CI key can never touch other workloads.
Manage computer science courses, term semesters, lab assignments, student cohorts, and join codes with direct instructor access to student projects.
Set strict monthly, term-based, or one-time spending limits that halt workloads when reached, keeping department or client budgets safe.
Isolate workloads using seven distinct Linux namespaces, unprivileged root UID remapping, dropped kernel capabilities, and 33+ blocked syscalls.
One product
Projects, deployments, persistent storage, team permissions, and networking combined in a single coherent model — with pricing you can easily calculate in advance.