Using the dashboard

Orbita is installed and you're looking at the login screen — now what? This page walks the whole dashboard, from creating your account to a live app and back-ups. It's the browser-only path; the CLI mirrors it for people who prefer the terminal.

The shape of it: register → organisation → project → app → configure → deploy.

1. Register your account

Open the dashboard (https://orbita.example.com, or http://YOUR_IP:8080 in IP mode) and click Register. Fill in your name, email, and a password.

The first person to register becomes the super-admin, with full control of the box. Do this the moment install finishes. If a stranger reaches the URL and registers first, they own your server.

Once that first account exists, public registration is closed automatically — /register returns 403 for everyone else. You don't have to do anything.

After that, people join in one of two ways:

By invitation — see step 8. The invite link lets them create an account even though sign-up is closed, and drops them straight into your org.
Created for them — you set their email and password directly and hand the credentials over. This is the path when email isn't configured.

Want an open instance instead?

To let anyone sign up (a public PaaS, say), set ORBITA_ALLOW_OPEN_REGISTRATION=true in /opt/orbita/docker-compose.yml and recreate the container. ORBITA_DISABLE_REGISTRATION=true remains a hard lock that blocks even invited users.

Email, and the no-email path

Orbita uses Resend for invitations, password resets, and deploy notifications. Configure it under Admin → Email: paste an API key, set a from-address on a domain you've verified with Resend, and send yourself a test to confirm delivery. The key is stored encrypted and overrides the RESEND_API_KEY environment variable, so you can turn email on without SSHing in or restarting.

You don't have to configure it. With no email provider, invitations can't be delivered — so instead of inviting people, you create their accounts directly and pass the credentials on yourself. Everything else works the same.

Onboard a tenant directly

Admin → Organisations → New tenant creates an organisation and the account its admin signs in with, in one step:

Organisation — name, and a plan as the resource baseline.
Resource overrides — optional. Fill in only what differs from the plan; blank inherits. This is how one client gets 4 GB while everyone else stays on the plan's 512 MB.
Org admin — their email and name. A strong password is generated for you (edit it if you prefer), and you choose whether they're owner (full control of their org) or admin.

Orbita then shows the sign-in URL, email, and password once, with a copy button. The password is not stored in plaintext and cannot be retrieved again — copy it before leaving the page.

They must set their own password

The account is flagged so the handover password only works once. At first sign-in the user is sent to Set your password and can't do anything else until they choose one — the API refuses every other request, not just the dashboard. Changing it also signs out every other session, so a credential that leaked in chat stops working.

To add more people to an existing org without email, use Members → Add user, which works the same way.

2. Create an organisation

An organisation is your top-level workspace. Every app, database, and domain lives inside one, and each org is fully isolated from the others — its own Docker network, encryption key, and resource quota.

Click Create Organisation, give it a name (e.g. Acme), and you're in.

3. Create a project

Inside the org, apps are grouped into projects, and each project has one or more environments (like production). Create a project (e.g. Website) — you'll pick it when you create an app.

4. Deploy an app

From your project, click Create App. Orbita builds from one of two sources:

From a Docker image

The quickest way to see it work — anything on Docker Hub or GHCR, no build needed:

Source: Docker Image
Image: nginx:alpine (or ghcr.io/you/app:v1.2.3)
Port: the port your image listens on (e.g. 80)

Click Create, and it deploys.

From a Git repository

Builds your code into an image on every push.

Connect Git first. Go to Settings → Git Connections and add a GitHub token (scopes: repo + admin:repo_hook). This lets Orbita clone private repos and set up auto-deploy webhooks.
Back in Create App, choose Source: Git Repository, pick the connection, repo, and branch.
Choose a build method:
- Nixpacks — Orbita auto-detects the language (Laravel, Django, Rails, Node, Go, static sites and more) and builds it with no Dockerfile.
- Dockerfile — Orbita builds the Dockerfile in your repo. Set the Dockerfile path (default Dockerfile) and a build context if it isn't at the repo root.

Orbita builds the image and deploys it. Every future git push to that branch redeploys automatically.

Option C — Docker Compose

For an app made of several services, choose Source: Docker Compose. Point Orbita at a compose file in your repo (path defaults to docker-compose.yml) or paste one in, then name the web service — the service that serves HTTP.

Orbita deploys the file to Docker Swarm as a stack. The web service gets your domains and TLS; the rest stay private to the stack and reach each other by compose service name, exactly as they do locally. Stopping, starting, or deleting the app applies to every service in the stack.

Your Environment variables are injected into every service in the stack, so a worker gets DATABASE_URL just like the web tier does. A service's own environment: block still wins if it sets the same key. The port you set is the port your web service listens on — it's required for Compose, since that's what domains route to.

Compose limits worth knowing

build: works only when the compose file comes from a Git repo — pasted YAML has no source tree to build from. Pasted files must reference prebuilt images.
Rollback isn't supported for Compose apps: a compose deploy has no single image to revert to. Redeploy the previous commit instead.
Only the web service is routable. Give another service its own domain by splitting it into its own app.
The app's memory/CPU limits apply to the web service. Size other services with deploy.resources in the compose file, which can set them per service.
Multi-line env values (a PEM key, for example) can't be passed to a Compose stack and are skipped with a warning in the deploy log.

5. Configure the app

Open the app to reach its tabs: Overview, Deployments, Logs, Metrics, Environment, Terminal, Domains.

Environment variables

Under Environment, add variables one per line in .env style, or paste a whole block. Mark anything sensitive as a secret — it's encrypted at rest with your org's key and never shown again after saving.

A domain and HTTPS

Under Domains → Add, enter a hostname (e.g. shop.example.com). Point that name's A record at your server first (see Getting started, step 2). Traefik fetches a Let's Encrypt certificate on the first request — the app is then live over HTTPS.

A database

Databases are created at the org level, not inside the app. Go to Databases → Create, pick Postgres, Redis, or MinIO, and Orbita provisions it inside your org's private network. Copy the connection URL it gives you into the app's Environment (e.g. DATABASE_URL). Nothing is exposed publicly — the database is reachable only from your org's apps.

6. Watch it deploy

Deployments — every build, with its status and time. This is also where you roll back.
Logs — live output from the running container (streamed).
Metrics — CPU and memory for the app.
Terminal — a shell inside the running container, in your browser.

A deploy goes build → start → health check → route. When it's healthy and a domain is attached, your app answers on that domain over HTTPS.

7. Roll back

Made a bad deploy? Open Deployments, find the previous good one, and click Rollback. Previous images are kept, so it's an instant image swap — no rebuild.

8. Invite your team

Add people under Members → Invite (org admins only). Enter their email and a role:

Role	Can
viewer	See apps, logs, metrics
developer	Deploy, manage env + domains
admin	Manage members, git connections, everything in the org
owner	Admin + transfer/delete the org

They get an email with a join link. The link lets them create an account even though public sign-up is closed — they don't need one beforehand, and you don't need to reopen the instance.

If email isn't configured, use Members → Add user instead: set their password directly and pass the credentials on yourself.

What works today

All of these deploy end to end: Docker images, Git repos with Nixpacks (no Dockerfile), Git repos with a Dockerfile, Docker Compose stacks, and Grit apps (zero-config).

Known gaps, stated plainly: Compose apps can't be rolled back (redeploy instead), only the nominated web service in a stack is routable, and pasted compose files can't build: from source.

Getting started — the full install-to-first-app walkthrough.
Deploying Grit apps — zero-config deploys.
CLI reference — the same operations from your terminal.

Getting started Deploying Grit apps