Skip to content
v0.0.1 Betais now live

The PaaS experience on infrastructure you already own.

TurboV is a hosted deployment platform for your own servers. Sign up, connect any Ubuntu or Debian VPS, and push to deploy, with automatic HTTPS, live logs, one-click rollbacks, and managed databases, for the price of the server.

Deploy free See how it works

Works on the servers you already have

  • Hetzner
  • AWS EC2
  • DigitalOcean
  • OVHcloud
  • Vultr
  • Linode
  • Ubuntu
  • Debian

Any Ubuntu 20.04+ or Debian 11+ server, cloud or bare metal · x86_64 or arm64 · 1 vCPU / 1 GB minimum

installs Docker and Traefik and brings a new server online.
1command
of managed databases: Postgres, MySQL, Redis, and MongoDB.
4engines
markup on compute and bandwidth. Your provider bills you directly.
0%
platform fee on the free tier.
$0

Comparison

Bare-metal economics without the bare-metal toil.

Raw servers are cheap and laborious. Managed platforms are effortless and metered. TurboV keeps the server bill and removes the operational work.

Comparison of Raw VPS or Dokku, Vercel or Render, and TurboV across seven dimensions
MetricRaw VPS / DokkuVercel / RenderTurboV
Monthly cost at scale
Low
$5–40 per server. No platform fee.
Metered
Per-seat plans plus bandwidth, build-minute, and instance overages.
Server cost only
$0 control plane on the free tier. Compute and bandwidth are billed by your provider, with no markup.
Zero-config TLS & domains
Manual
certbot, nginx vhosts, renewal cron. Dokku via plugin.
Automatic
Managed certificates and DNS on the vendor edge.
Automatic
Traefik issues and renews Let's Encrypt certificates on your server.
Instant rollback
Manual
Re-tag, rebuild, and redeploy by hand.
1-click
Previous builds retained on vendor storage.
1-click
Recent images stay on your server, so a rollback skips the rebuild.
Databases & backups
DIY
Install, secure, and schedule backups for each engine yourself.
Add-on
Managed instances, billed per plan.
Built in
Postgres, MySQL, Redis, and MongoDB on your server, backed up to your own S3-compatible bucket.
Ownership & control
Full
Everything stays on your server.
Vendor-held
Source, env vars, build and runtime logs on third-party infrastructure.
Your hardware
Apps, builds, databases, and traffic run on servers you control. Secrets are encrypted with Google Cloud KMS.
Platform to maintain
Yours
You install, patch, and upgrade Dokku or your own scripts.
None
The vendor runs the platform.
None
We run and update the dashboard and API. The agent on your server updates itself.
Setup complexity
High
SSH, compose files, systemd units, firewall rules.
Low
Connect a repo and deploy.
Low
Sign up, paste one install command per server, then connect GitHub and deploy.

How it works

We run the platform. You bring the servers.

TurboV runs the dashboard and coordinates your deploys, so there is nothing for you to host or upgrade. Your servers build, run, and serve your apps, and if the dashboard is ever unreachable, they keep serving.

  1. 1

    Add your server

    Sign up, add a server in the dashboard, and run the install command it gives you. It installs the TurboV agent with Docker and Traefik, and the agent connects out to TurboV, so you only need ports 80 and 443 open.

    curl -fsSL https://install.turbov.io | sudo bash -s -- --token tk_…
  2. 2

    Connect a repo

    Install the TurboV GitHub App on the repositories you choose, then pick a repo and a branch. TurboV detects your stack, or uses the Dockerfile you already have.

    acme/api → main
  3. 3

    Push to deploy

    Every push to your branch starts a deploy. Your server clones, builds, and starts the new version, and Traefik routes your domain to it over HTTPS.

    git push origin main

Anatomy of a deploy

What happens on git push

  1. You push

    GitHub sends TurboV a webhook with the new commit.

  2. Your server gets the job

    The agent on your server picks up the deploy over the connection it opened to TurboV. No inbound management ports needed.

  3. Your server pulls and builds

    The agent clones the repo straight from GitHub and builds the image locally, from your Dockerfile or a generated one.

  4. The new version starts

    The new container starts on your server's private Docker network, ready to take over from the previous release.

  5. Traefik routes the traffic

    Traefik points your domain at the new container and serves it over HTTPS with an automatic Let's Encrypt certificate.

TurboV coordinationyour source codeuser traffic

TurboV coordinates the deploy. Your code is cloned, built, and served on your own server, and requests from your users reach your apps without passing through TurboV.

Platform

The parts of a PaaS you would otherwise script yourself.

Console output

Streaming from api

INFO14:02:23GET /v1/users 200 12ms
INFO14:02:24GET /healthz 200 1ms
INFO14:02:25GET /v1/products 200 9ms
INFO14:02:26GET /v1/orders 200 31ms
ERROR14:02:27error: pg pool exhausted (20/20)
INFO14:02:28POST /v1/checkout 201 88ms
INFO14:02:29job=invoice.send ok 214ms
INFO14:02:30POST /v1/webhooks/stripe 200 44ms
ERROR14:02:31error: upstream timeout (stripe) 504

App · Logs

Live logs, filtered by level

stdout and stderr from your app's container, streamed to the dashboard as they happen. Narrow it down to errors in one click.

  • checkout: retry stripe 5xx with backoff

    Active
    a7f3c2e1m 12s
    Success

  • orders: paginate /v1/orders

    5d02b9158s
    Success

  • deps: bump pg to 8.12

    e81c4a01m 04s
    Success

  • api: add /healthz readiness probe

    39bf7d21m 21s
    Success

Deployments

Instant rollbacks

Recent deployments stay on your server, so going back to a known-good version skips the rebuild. Changed your mind? Promote the newer one again.

Build plan

acme/web

Detected
Node.js · Next.js
Dockerfile
generated for you
Port
3000

Build plan

Zero-config builds

TurboV reads your repository, detects the stack, and builds it. Already have a Dockerfile? It gets used as-is, and Docker images from a registry deploy too.

Simulated per-app CPU, memory and network usage
AppCPUTrendMemoryNet I/O
api
46%
212 / 512M↓1.3 ↑0.4 MB/s
web
34%
198 / 512M↓1.2 ↑0.4 MB/s
worker
15%
96 / 256M↓0.1 ↑0.1 MB/s
admin
19%
140 / 256M↓0.2 ↑0.3 MB/s

App · Metrics

Metrics for every app

CPU, memory, and network for each app, plus request and error rates from Traefik, all in the dashboard. There is no exporter or metrics stack to set up.

Databases

  • postgres 16
    Running
  • redis 7
    Running
  • backup → s3://acme-backups
    ✓ 214 MB

Databases

Managed databases with backups

Postgres, MySQL, Redis, and MongoDB run on your server next to your apps. Back up to your own S3-compatible bucket and restore when you need to.

Environment variables

  • DATABASE_URL
    ••••••••••
  • STRIPE_SECRET_KEY
    ••••••••••
  • REDIS_URL
    ••••••••••

Settings · Env

Encrypted environment variables

Values are encrypted, with keys managed in Google Cloud KMS. Set them once for a project, then override them per environment.

Domains

  • api.acme.devDefault
    Active
  • acme.dev
    Active
  • app.acme.dev
    Active

Domains

Custom domains with automatic HTTPS

Point a DNS record at your server. Traefik requests a Let's Encrypt certificate and renews it automatically.

Also included
  • Persistent volumes
  • Docker image deploys
  • CPU & memory limits
  • Teams & roles
  • API keys
  • Audit log
  • Self-updating agent

Security & control

The work happens on your server.

Builds, containers, databases, and traffic all live on hardware you control. TurboV coordinates deploys from the side, which keeps your data-flow diagram short and your infrastructure review simple.

Source & builds
Your server clones the repository from GitHub and builds the image itself, so build load and build artifacts stay on your hardware.
Traffic & network
Users reach your apps directly through Traefik on your server. TurboV is never in the request path, and it asks for no inbound ports beyond 80 and 443.
Secrets
Environment variables are encrypted with AES-256-GCM, and the keys that protect them are managed in Google Cloud KMS.
Access
Each server joins with a one-time token and keeps its own revocable session. Teams get Owner, Admin, Member, and Viewer roles, scoped API keys, and an audit log.

Pricing

Start free. No platform fee.

Put your apps on a $5/mo VPS and pay your provider directly. TurboV adds no markup on compute or bandwidth.

Deploy free
Monthly bill · 5 apps, 1 hostFree tier
$1.00
per app, per month
$5.00 ÷ 5
VPS (your provider)
$5.00
TurboV platform
$0.00
Build minutes
$0.00
Bandwidth markup
0%
Total
$5.00

Illustrative. How many apps fit on one server depends on their size and traffic.

FAQ

Questions engineers ask first.

Something else on your mind? Check the docs.

No. TurboV is a hosted platform: we run the dashboard, the API, and deploy coordination, and you sign up at app.turbov.io. You bring the servers your apps run on. The only TurboV software on them is the agent, and it keeps itself up to date.

Ship your next push to your own server.

Sign up, add a server, push. Start on the free tier.

root@fsn1-vps-01
# install command from your TurboV dashboard
$ curl -fsSL https://install.turbov.io | sudo bash -s -- --token YOUR_TOKEN
✓ docker and traefik ready
✓ host fsn1-vps-01 registered
# connect acme/api from the dashboard
$ git push origin main
✓ https://api.acme.dev is live
Deploy free See how it works