Skip to main content

Delivery Process

How work in a software project goes from a signal to a closed task, once, for every project. A task's state lives in Flow; each tick reads it, applies the transitions that came due and writes the result. This is the engine; each project extends it with its answers to the parameters, and a project with no answer gets the default. The process is Get Things Flowing (GTF) applied to product development: the rule ids below are GTF's.

Three rules​

The rules of any work are GTF's, cited below by id. Three are the delivery process's own:

  1. One owner per transition. Only a stage's owner changes the task's state in that stage. Two owners drift apart silently, each acting on a state the other already changed.

  2. Rounds have a limit. Each reason a change goes back (red checks, findings) gets the automatic rounds the Merge rule allows; the next goes to a person, and so do findings the Merge rule gives to a person, with no round (The author never verifies its own work).

  3. What ages fastest goes first. Work is ordered by its cost of delay, read from the stage the work is in and the one word a person may say about it, never estimated per task (Cost of delay orders the work). The tick works, in order:

    1. a repo whose default branch is red: its repair, since it holds every change in the repo;
    2. a task at very_high priority, bug or not, in any stage, asserted or inherited from an open commitment it blocks (Flow's inherited_priority);
    3. a bug (a task tagged bug) at high, asserted or inherited;
    4. what integrated and nobody has seen in effect;
    5. the waits that came due;
    6. what is open at its gates (a conflict, a fix round or a review the agents run), among which only Flow's ranking orders;
    7. new work.

    Every other priority a person set orders the work inside a stage, never across stages. The order fills two limits apart: children that push a change from Max runs, checks and reviews from Max short runs.

Words​

The process names acts, not tools, so it reads the same on any code host and for deliveries that are not code:

WordWhat it isExamples
changewhat alters the product or its worlda pull request (the default), a merge request, a commit, a post, a CMS entry, a flag, a migration
gatea check a change must passCI, an agent's review, a person's review, an approval, a store's review
integratethe act that makes a change officialmerge, publish, apply, execute
releasewhat puts an integrated change in effectdeploy, publish a package and bump its consumer, roll out
verifyobserve the effect where it mattersa production query, a registry install, a device, a dataset

The stages​

#StageOwnerStarts whenWrites to Flow before it endsParameter
1Intakewhoever finds the signal: an intake routine, a person, an agent mid-taskan alert, feedback, an idea, a findinga task with its source and what was investigated, active, or, when found mid-task, active when it leaves the product unchanged, else incubated, or what the standing decision names (GTF-C1); never a fixIntake
2Decidea persona choice the work needs, or a brief short of the Ready briefthe answer, on the task that waits on them (the move that frees it cites their words), or as the outcome of a decision that holds several tasksDecisions, Ready brief
3Implementa child run, or a personthe task is ready and its brief is recorded ready, or a round sends it backthe change, which improves the code it touches and widens no further, proposed ready (not draft); an implements reference; after_integration, what integrating leaves (close, a release step, or a check with what to observe, where and when it can be seen), following the closing validation the brief names; in the change's description, the task's URL, the tasks it settles, and the assumptions made and the choices answered on the way, each with what was checked (Decisions); the task waiting on the gates, on a person only when the change touches a path the Merge rule reserves to them, naming itBefore proposing
4Gatesautomation, the reviewer Review names (a review child of the tick, a project routine or a person), the person the Merge rule reservesthe change is proposednothing on the task: verdicts stay on the change, each bound to the commit it judged (the flow/review status), and the tick writes after themReview, Merge rule
5Integratewhoever the Merge rule lets integrate: the reviewer, the tick or a personthe gates passnothing on the task: the tick writes what integrating leavesMerge rule
6Releasethe Release procedure: automation, a child run or a personintegrationa release step that is somebody's act is its own task that blocks the integrated task (GTF-N4); a pipeline every integration runs is a wait, not a taskRelease procedure
7Verifythe reader the Closing evidence names, else a check child of the tickthe check comes duecompleted with what was observed, or active again with it (GTF-E8), the change reverted first when what was observed is harmClosing evidence

A stage a project, or a delivery kind, answers with "none" is skipped: with no review, the gates are the checks; with no release, integrated is in effect once its pipeline passes. A gate may also run after integrating, as in trunk-based work: its failure is the "pipeline red after integrating" transition below.

Where work waits​

The work that waits in this process waits on a person, in one of two queues on either side of Implement. Everything else the agents drain on their own. Why each is named, counted and held by its own rule is in Principles.

The release queue is every change between its implementation and its release to the customer in production, the stages from Gates to Verify: a change open past draft, at its gates or with a person to integrate it, and an integrated change whose task waits on a person to see it in effect, such as a validation or a feature flag's removal, or whose check came due. A validation the person scheduled for a later date, each of their waits scheduled and still in the future, is held by that decision, like incubated work, and enters the queue on its date; an external wait on a person has a date that is only when to chase it, so it counts from the integration; a wait on nobody is outside the team, and holding new work would not drain it, so it never counts. Its limit is the Release queue parameter. Once the queue reaches it, the tick starts no new work that a person would have to move, and spends its runs on what drains the queue, by rule 3. A task whose path to production reaches no person still starts, as many at once as the Person-free lane parameter allows: its closing validation closes it at integration, the Merge rule lets the agents integrate what it touches, it needs no flag, manual step or release a person takes part in, and its brief leaves no choice open. It holds the lane from its start until it closes, and one that lands on a person after all counts in the queue like any change. What the Chase and the Health do with a full queue is in Routines.

The decision queue is every open choice that holds work before it can start, the Decide stage: a decision that blocks the tasks it holds, or a task waiting on a person for an answer its brief needs. Most choices never enter it, because the Decisions default and the project's standing decision answer them by rule. A decision holds only the work it blocks, so it never counts against the release queue (A choice is answered by a rule where one exists).

Who writes the task​

  • After the verdict, the tick is the only writer of the task's status and wait (GTF-S3). It writes every transition whose owner does not write to Flow, such as CI, the code host, or a person who merged or reviewed, and every one an owner left unwritten. A run that only contributed to a stage, such as a reviewer, leaves its verdict on the change and writes at most references for what it produced.
  • With no tick, because nothing schedules one, the next run that reads the graph writes what the tick would.
  • Whoever writes or refines a brief may record that it is ready, as the same tag the tick writes, so the tick's reading is only the fallback for a task that arrives without it. An agent that rewrites a brief recorded ready removes the tag, and the next tick reads it again.
  • A brief with a change out is not rewritten. While a task carries an open implements change, its title and brief stay as that change implements them: new or wider scope is a successor task, derived_from it, and a round adds its log or findings to the body without changing the acceptance. A run that wrote a task earlier reads it again before writing to it again, and its write names the version it read (if_unmodified_since), so a concurrent write is flagged instead of lost.

States​

Where the task isStatusWhat holds itWho acts next
Readyactivenothingthe tick delegates it, or a person takes it
A choice for a personwaiting, or active behind a decisionan external wait on the person, or the decision's blocks edgethe person
At the gateswaitingexternal, on nobody: the gates the change waits onthe gates; the tick reads the verdict
A round backactivenothing; the body carries the log or the findingsthe tick delegates a fresh child
Reserved for a personwaitingexternal on the person, naming what is ready for themthe person
Waiting for a releaseactivethe release task's blocks edge (readiness blocked:dependency)the release's owner
Waiting for the checkcalendarscheduled: the check and its datethe check's reader
Donecompletednothingnobody

Transitions​

The tick applies these on every tick, under the standing decision:

WhenThe tick
A new task, nothing holding it, and nothing records whether its brief meets the Ready briefreads the brief once and writes the answer before it plans again: ready, a tag on the task; short, a wait on the person naming what is missing; more than one delivery, the split. A brief recorded ready is never read again by a tick
The change's checks pass with no verdict for its head, and Review gives the review to an agentstarts a review child, which leaves its verdict on the change, unless a reviewer claimed the head within Stale after
The change's checks pass with no verdict for its head, and Review names a reviewer outside the tickwaits: a missing verdict is never a passed gate
The gates pass (a verdict for the head, or Review none) and the Merge rule lets the agents integrateintegrates the change, when the code host requires that review; otherwise moves the task to waiting on a person, naming what is ready
Checks red, or findings, within the round limitmoves the task to active with the log or the findings in the body, for a fresh child on the same change
Findings the Merge rule gives to a person (a finding only a person can act on, or a change it reserves to a person)moves the task to waiting on that person, naming the findings, with no round
The round limit reached (rounds are the task's fix runs; a red caused outside the change, such as a broken default branch or infrastructure, does not count)moves the task to waiting on a person
A review request lost: no verdict and no claim Stale after after the checks passed, or a claim that outlived it with no run holding the taskapplies the Review fallback
The change needs what the Merge rule reserves to a personmoves the task to waiting on that person, naming what is ready
A conflict with the default branchmoves the task to active for a fresh child that resolves it
A step only a person can do before integrating (a migration, a manual check)writes that step as a task, theirs, that blocks the task (GTF-N4)
The change closed without integratingretracts its implements reference and moves the task to waiting on a person: implement it again, or cancel it. A change of the task in the same repo that integrated or is still open superseded it: the tick only retracts the reference, and the task follows that change
The change integrated, nothing written sinceapplies the task's after_integration: closes it on immediate evidence, citing the change; or the release step; or the check's wait. A task with several changes waits for the last one
A task nobody holds (no person, run or blocks edge) is active, written after its change integratedreads why from its history (The graph is the state): sent back by a failed check, a revert or a person asking for rework → a round on a fresh change; a person cleared its check's date early → starts the check child; its last write only handed it off, citing a change that had already integrated → applies its after_integration
The check's wait is applieddates it by the check's visible_at, or now when that date has passed (GTF-E8)
The task waits on a person because nothing said what integrating leaves, and its after_integration is now writtenapplies it as above: that write is the person's answer, never a sign the tick already acted
The task carries an after_integration and a different wait on a person, such as a check child's for an act only they can doleaves the wait: it is not answered by an after_integration the task already carried
The task carries no after_integration and its brief names a closing validationapplies that validation's level as above: the brief already said what integrating leaves
The Closing evidence gives the agent the choice of what integrating leaveschooses the level itself from the change and the task, with its reason, instead of the wait; a wait it wrote before the parameter said so is read again on the next tick
The integration's pipeline redreverts the change by the reversal path its description records (Before proposing), then moves the task to active with the log and the revert, a round: a defect in effect costs by the hour, a round costs a child and its checks
The integration's pipeline red, and the change records no reversal pathmoves the task to waiting on a person, naming the red
A repo's default branch redopens the repair task, which blocks each task the red branch holds, so its leverage is what puts it first; the red is the repair task's, never a round on the changes it holds
The change's description names other tasks it settlescloses them on integration, citing the change, as far as the standing decision delegates tidying (GTF-S6)
A change in the project's repos names no taskapplies the Intake answer: writes a task for it, or leaves it
A release step's task closesmoves each integrated task it held to its check's wait, or closes it citing the release task, whose outcome is the evidence: once the edge stops holding it, the task is active and ready, and only this transition keeps it from reading as new work
A task is held only by blocks sources whose change integrated and that stay open (a release or a check later)reports it, and the Chase lists it for a person, who retracts the edge to start it now or keeps it until the sources close; the edge keeps gating until then. It retracts the edge itself, recording a mentions with the change, only when the standing decision delegates that (Autonomy is bounded by reversibility)
A check comes duestarts a check child (unless the Closing evidence names another reader), which closes the task with what it observed or sends it back; harm the change caused is reverted first, as in the "pipeline red" row
A child's run failed, is gone, or stays running past the Runtime's Stale after with its task opencloses the run failed; the task is ready again
A run startsrecords Stale after as its hold, so Flow keeps its tasks from other runs exactly that long
Another agent's run, such as a person's session, holds an open task past Stale afterleaves it to the run's owner

A person reviewing a change has three outcomes: integrate it, ask for changes (the task goes back a round), or close it, which is the "closed without integrating" row.

Delivery kinds​

A pull request through the code host is the default kind. A project that also delivers in other ways (content, a CMS entry, a feature flag, manual infrastructure, a data fix) names each kind in Delivery kinds: its gates (a person's approval when the act reaches outside the product), who integrates it (executes it), and what proves it. Each kind runs the same stages; most just answer "none" to more of them.

Prerequisites​

  • The code host enforces the Merge rule. Required checks, branch protection and required reviews make the rule true for everyone, not only for the agents. With a reviewer in Review, its verdict is the flow/review commit status on the head and a required check, so a verdict is bound to its commit and only an identity with write access can give it; without that, the tick integrates nothing and waits on a person.
  • What judges or instructs the agents changes only through a merge a person approved: the CI configuration and required checks through code owners or the host's equivalent, and the agent instructions the same way, so the standing decision can point at the instructions (GTF-A6).
  • The runtime allows every act the standing decision delegates. An act the runtime refuses, such as a merge or a release step its permission rules block, moves the task to waiting on a person, naming the refusal (GTF-U3).
  • Something fires the runs. Flow keeps the state but wakes nobody (GTF-S5): the project's routines start each run fresh from the graph.