Deploy your GitHub repos to your own server.

Connect a repo, point Orbiitl at a VPS you already pay for, and get a live HTTPS URL. It figures out how to build your app, so you don't have to write a Dockerfile or a pile of YAML. Every git push after that redeploys on its own.

Works with Next.js, Express, Node, Django, FastAPI, Flask, Streamlit, React/Vite front-ends and plain HTML sites, or any repo with a Dockerfile.

What a deploy looks like after you push
$ git push origin main
✓ Webhook received, redeploying acme/storefront
✓ Detected Next.js 14 (port 3000)
✓ Tests passed (npm test, 38 passed)
✓ Built image (41s, cached layers)
✓ Container healthy, certificate issued
→ Live at https://storefront.example.com

How it works

  1. Connect GitHub and your server

    Sign in with GitHub, then paste one install command on any Ubuntu or Debian VPS. A small agent starts up and checks in with Orbiitl.

  2. Orbiitl reads the repo

    It looks at files like package.json and requirements.txt to work out the framework, port and build steps. If you have a Dockerfile, it's used as written.

  3. Click deploy

    Pick a branch. The agent builds a container, checks it's healthy and serves it over HTTPS. From then on, every push redeploys automatically.

What you get

The things you'd normally pay a hosting platform for, running on a server you control.

Redeploy on every push

GitHub webhooks kick off a fresh deploy. Push again mid-deploy and the newer one takes over.

Tests run first

Your test suite runs before the image is built. A failing test stops the deploy before it reaches production.

Live logs

Watch the build as it happens, see the last 30 minutes of request logs, and export them as CSV.

HTTPS out of the box

Each app gets its own subdomain with a certificate that's issued and renewed for you. Bring your own wildcard domains too.

Workers, cron jobs and Redis

Run background workers from the same build, schedule commands with cron, and switch on Redis with one toggle. Its connection details are filled in for you.

Quick builds

Only the services whose folders changed are rebuilt, dependency caches are reused, and separate projects build in parallel.

Email when it matters

Get an email when a deploy succeeds or fails, and a warning if a live app keeps crashing. The projects list shows exactly which commit is live.

An agent that looks after itself

It updates itself, clears stuck jobs, frees disk space and can set up an extra blank disk for you.

Ready for more than one app

Once the first deploy works, these are what make it something you can keep running.

Staging and production

Give a project several environments, each with its own branch, environment variables and URL. They run side by side on the same server.

Frontend and backend in one repo

Monorepos with folders like frontend/ and backend/, or apps/*, are split into services and deployed together. A frontend's API_URL is pointed at the backend for you.

Roll back to any commit

Pick an older commit from the redeploy dialog and it goes live again. A new build is only switched to once it passes its health check, so a broken one never takes over.

Errors in plain English

When a deploy fails you get a short explanation, like "ran out of memory" or "wrong port", next to the full raw logs.

Environment variables, kept safe

Paste a whole .env file or add them one at a time. Values are encrypted, and you can see what a variable was set to before. Backend secrets never end up in frontend code.

Private services and shared domains

Keep an internal API off the public internet, or serve it at /api on your frontend's domain instead of its own subdomain. Custom domains work too.

Deploy from your AI assistant

Orbiitl has an MCP server, so Claude Code, Cursor, VS Code and other assistants that speak the Model Context Protocol can work with your account. Ask things like "why did my last deploy fail?" or "redeploy my-app from the latest commit" without leaving your editor.

  • Deploy any branch or commit, then follow its status and logs.
  • Stop, restart or delete a project.
  • Set and link environment variables. Values can be written but never read back, so secrets stay in the dashboard.
  • Check your servers' health.

It acts with your account's permissions and only sees your own projects. Revoke the token and access stops straight away.

  1. In the dashboard, go to Settings → API Tokens and create a token. It starts with pat_ and is shown once.
  2. Add Orbiitl to your assistant. In Claude Code:
claude mcp add --transport http orbiitl https://app.orbiitl.in/mcp --header "Authorization: Bearer pat_..."

Other assistants take a JSON config:

{
  "mcpServers": {
    "orbiitl": {
      "type": "http",
      "url": "https://app.orbiitl.in/mcp",
      "headers": { "Authorization": "Bearer pat_..." }
    }
  }
}

What runs on your server

Orbiitl has two parts: the control plane, which reads repos and plans each deploy, and a small agent on your server. The agent can only do a short list of things. It can't be asked to run arbitrary commands.

  • A fixed set of actions. Deploy, stop, restart and remove. Nothing else.
  • Apps are isolated. Each one runs with resource limits and no direct access to the host.
  • Secrets are encrypted. GitHub tokens and environment variables are encrypted at rest. Clone tokens stay in memory and are never logged.
  • Your code stays with you. Builds and containers run on hardware you control.

Getting started

You need a GitHub account and a Linux VPS (Ubuntu 22.04+ or Debian 12+, 2 GB RAM or more) with ports 80 and 443 open. A DigitalOcean droplet, a Hetzner server or an AWS, GCP or Azure VM all work.

  1. Sign in to the dashboard with GitHub.
  2. Go to Servers → Add Server and copy the install command.
  3. Run it as root on your VPS. It looks like this:
curl -fsSL https://app.orbiitl.in/install.sh | sudo SERVER_ID=<id> AGENT_TOKEN=<one-time-token> API_BASE_URL=https://app.orbiitl.in sh

The dashboard gives you the real command with a one-time token (shown only once). Your server should show up as online within a few seconds.

Pricing

You already pay for your server. Orbiitl is a monthly plan on top, with no charge per build, per seat or per gigabyte. Contact sales and we'll work out the amount with you.

Solo

For solo developers and pre-revenue founders

Custom pricing

Email kunwarsingh040126@gmail.com to discuss pricing

  • 1 server, up to 2 apps
  • Support replies by the next working day
Contact sales

Agency

For agencies

Custom pricing

Email kunwarsingh040126@gmail.com to discuss pricing

  • All your client projects
  • Support replies within 1 hour, 24x7
  • Per-client access controls
Contact sales

Every plan includes everything on this page: auto-deploy on push, HTTPS, live logs, staging and production environments, workers, cron jobs, Redis and MCP access for AI assistants.

Do I pay for the server too?

Yes, separately, to your own VPS provider. Orbiitl never bills you for the server.

What happens to my apps if I stop paying?

They keep running on your server. Your projects stop auto-deploying and paid features pause until you upgrade again.

Can I pay in USD?

Yes. Ask for a USD payment link and you'll be billed in dollars by card.

How do I pay?

By a payment link sent over email.

Who's behind it

Hi, I'm Kunwar Singh Kataria, the developer building Orbiitl.

If something breaks or you have an idea, email me directly. I read everything.

Questions people ask

Which languages and frameworks are supported?

Next.js, Express and other Node.js apps, Django, FastAPI, Flask and Streamlit, front-ends built with Vite or Create React App, and plain HTML/CSS/JS sites. If your repo has its own Dockerfile, it's used exactly as written. If Orbiitl can't tell how to build something, it tells you instead of guessing.

Do I need to write a Dockerfile?

No. Orbiitl works out the build from your project files. If you already have a Dockerfile, it's used instead.

Can I deploy docker-compose stacks?

Not yet. Each service runs one main app container, plus optional worker commands and a Redis instance. If your repo has a frontend and a backend in separate folders, Orbiitl deploys them as separate services without needing a compose file.

Do I need my own domain?

For HTTPS, yes: add a wildcard domain and every app gets its own subdomain and certificate. If you just want to try something out, you can skip the domain and reach the app on your server's IP and a port instead (plain HTTP).

Can I have a staging copy of my app?

Yes. Add an environment to the project, point it at a branch like staging, and give it its own environment variables. It runs alongside production with its own URL.

What happens if a deploy fails?

Your current version keeps running. The new build only replaces it once it passes your tests (if you set a test command) and its health check. You get an email, a plain-English reason and the full logs.

Can my AI assistant deploy for me?

Yes, through the Orbiitl MCP server. Create an API token in the dashboard and add the server to Claude Code, Cursor or any MCP client. See Deploy from your AI assistant for the setup.

Give it a try

Connect a repo, add a server, and see your app live in a few minutes.

Open the dashboard