field · the deploy stage

Deploy what you specified.
Not a second guess.

Field takes the rules for going live straight from the spec. The way the work ships is read from what was agreed, not written again by hand and hoped to match.

Request access →
the problem

The deploy config is a second source of truth.

The spec says one thing. The deployment is set up by hand, weeks later, by someone reading the spec again and filling in the gaps from memory. The two drift apart, and the gap between what you designed and what actually runs is where incidents live.

what it does

One source. Spec to running system.

rules from the spec
How it deploys, what it needs, where it runs. Read from the same contract that Capture wrote, not invented at deploy time.
no hand-copy
Nobody re-types the design into a deploy config and hopes it lines up. The gap where that mistake lives is closed.
what runs is what you agreed
The running system can be traced back to the spec, the same way the code and the proposal can. One contract, all the way to production.

The contract Capture writes already carries what Field needs. That is why this stage is an extension of the same pipeline, not a separate tool bolted on at the end.

one policy, every environment

Dev, staging, production. Same rules.

Every environment foots onto the same policy, read from the spec. Nobody re-types the deploy by hand and hopes it lines up, so the gap where that mistake lives is gone.

what field reads

The deploy is in the contract already.

The things a person usually fills in by hand at deploy time are already settled in the spec. Field reads them. It does not reinvent them.

where it runs
The environments, the regions, the ground it is allowed to sit on. Read from the spec, not chosen at the last minute by whoever ran the deploy.
what it needs
Resource limits, scaling rules, health checks. The numbers Rehearse set as targets become the numbers the deploy is held to.
how it rolls out
The rollout, the checks it must pass to go live, and the way back if it fails. Written once, in the same contract as everything else.
what it may touch
The secrets it can read, the network it can reach, the data it may hold. Scoped in the spec, so the running system can only do what it was cleared to.
where it sits

After the code. Before the world sees it.

Field takes the work Author built and puts it live under the spec's rules. It is the fourth stage of five, and it hands off to Track, which watches what you promised once it is running.

See the whole pipeline →