oxid

// install — 60 seconds

From nothing to a live preview.

No YAML novels, no secret juggling. Secrets generate themselves, the wizard does the rest.

$ curl -fsSL .../install.sh | sh -s -- --docker
[+] Dashboard: http://localhost:8080  → wizard

$ git push origin feature-carrito
[>] Building (cache hit: 85%) ...
[+] https://feature-carrito.local.dev

Traefik mode: stable subdomains + wake-on-request. Direct-publish: a host port each, no DNS. Install & setup · For developers · Stacks · Env vars · Security

// why

Staging environments shouldn't cost like production ones.

// the golden path

You never feel the machinery.

1. 01

   Install

   One command. Secrets generate themselves, printed once.

2. 02

   Wizard

   Token → infra bootstrap → register by Git URL. First deploy kicks off for you.

3. 03

   Push a branch

   That's the whole interface from then on. Auto-routed at branch.your-domain.

4. 04

   Breathe

   Idle → stopped, RAM back. Next visit → awake in under a second.

Every command speaks --json with distinct exit codes for CI pipelines, and your shell gets tab completion via oxid completions zsh.

// benchmarks

Measured on real hardware, not asserted.

Every number below comes from the same box running the same load, once against the commit before the work and once against the commit after — two real binaries, not a flag. Medians of five runs after a warmup — three for the deploy figure, which costs a minute a run — with each daemon measured alone so they never competed for CPU.

Deploy throughput — fifteen branches pushed at once

A team starting its morning: fifteen simultaneous signed GitHub webhooks at one node, the full Docker and Traefik stack, timed from the first webhook to the last environment leaving building. All fifteen came up in every run.

Three things were in the way, each hiding the next. Every deploy on the node held one mutex, though sibling branches share no checkout, no container name and no environment row. A burst then waited out a whole scheduler tick doing nothing, because the pushes landed after the drain had already read the queue. And with those gone, every deploy was still doing its own git fetch, one at a time — fourteen deploys starting in the same millisecond and finishing 425 ms apart, which is exactly what a fetch to GitHub costs from this machine. One fetch brings down every branch, so they share it now.

Read the figure as a floor, and note which way: the Docker layer cache was warm here, so each build is a second or two. On cold builds the gap is larger, because what overlaps is then whole builds rather than the bookkeeping around them.

Heartbeat — the busiest path in the system

The proxy calls it on every HTTP request to every environment to keep idle detection honest. It resolves a hostname to its environment and records the visit.

Throughput used to be flat from 1 to 64 callers while latency climbed in lockstep — the shape of one serialized resource rather than a busy one. It now scales.

Authenticated read — the dashboard and oxid status

A single caller has nothing to overlap with, so it gains nothing — and that row is left in rather than dropped.

Where the speed came from

Three changes shipped, and they separate into two groups that can be measured apart — by re-running the new build with the pool forced back to a single connection. At 32 concurrent callers:

Reads tell the mirror-image story: the index and the write change do nothing for them (366 → 387 req/s), and the entire 3.5× is the pool.

Under the same load, 64 concurrent writers completed 4,800 writes with no lock contention errors. The box was not idle — it was running its owner's usual containers throughout, for both halves of every comparison. Full method and fixture in BENCHMARKS.md.