
Engineering note
Zero-downtime deploys: what actually happens after git push
A commit is not a deployment. Here is the full path a push takes through builds, health checks, traffic swaps and rollbacks — and the queue that keeps every release reversible.
Most platforms describe deployment as a single event: you push, and then your app is live. That framing hides the hard part. A deploy is a sequence of isolated steps, and each step has to succeed before the next one is allowed to touch production traffic.
This is the path every commit takes on weond, from the moment git push lands to the moment the old release stops receiving requests.

The queue is the contract
When a push reaches the control plane, it is not executed immediately. It is written to a durable deployment queue with the commit SHA, the target environment, the resolved build configuration and the previous healthy release.
Writing to a queue first gives us three important properties:
- Ordering — releases for the same project run one at a time.
- Replayability — a failed build can be retried without asking the author to push again.
- Auditability — every state change is attached to a deployment ID you can inspect in the dashboard or through the CLI reference.
A queue also makes deploys honest about failure. If the build sandbox crashes, the deployment stays in a failed state instead of silently disappearing.
Build in isolation
Builds run inside a sandbox with a read-only base image, a fresh copy of the repository and no inbound network access. Outbound traffic passes through Netguard, which enforces the project's egress policy before the container starts.
The build step is intentionally boring:
$ weond deploy --prod
› resolved commit 4f9c2a1
› detected runtime: dockerfile
› installing dependencies ........ done
› building ........................ done
✓ image pushed: sha256:9d31c0e
If any command exits non-zero, the pipeline stops, the logs are attached to the deployment, and production is never touched.
Health checks before traffic
A built image is not a live release. The new container starts next to the old one and has to pass the project health check: an HTTP request to a path you define, repeated until the configured timeout.
Only after the health check passes does the edge proxy begin shifting traffic. Existing connections are drained on the old release, and new requests are routed to the new one. This is the step that makes the deploy zero-downtime rather than merely automated.
A release is live when it can serve traffic — not when the build finishes.
Observability closes the loop
The deployment is not done when traffic moves. Runtime logs, request rates and error ratios are sampled for a short observation window. If the error budget for the release is exceeded, the platform can roll back to the previous healthy deployment without a rebuild.
That previous deployment is still available because releases are immutable. Rolling back is a pointer change, not a redeploy, so recovery is measured in seconds.
What this means for your workflow
You can keep treating git push as the interface. Underneath it, every release is queued, built, checked, observed and reversible. The next time a deploy feels instantaneous, remember that a handful of deliberate steps just ran in order — and that the old version is still there if you need it.
Want to see the pipeline in action? Start deploying and watch the first release move through each stage.