Skip to content

Project lifecycle, gates and change classes

Status
Approved
Version
0.2.8
Authority
UASK standard
Applies to
Core
Markdown source

Summary

Every project, whatever its size, moves through the same six phases: Idea, Blueprint, Spec, Build, Release and Support, with an optional seventh, Retire. Idea and Blueprint run once and again for a system change; Spec, Build and Release loop once per release; Support carries the project between releases. The owner decides at three gates (G0 Bet, G1 Blueprint approved, G3 Go-live); the lead decides at the others. Every phase opens with a recall step and closes with a record step. Two rules settle old conflicts: a backup proved by restore comes before the first change to a live system, and a live system serves as a test bed only by a written exception.

Rules

The phases

  • R1. A project MUST run its work through the phases Idea, Blueprint, Spec, Build, Release and Support, in this order, and MUST record the phase it is in where its state is kept. A project MAY add the optional phase Retire after Support.
  • R2. Idea and Blueprint MUST run once for a project and again for a system change (R10). Spec, Build and Release MUST run once per release. Support MUST run whenever a released system is in use.
  • R3. A tier (mgmt.governance-tiers) MAY shorten the artefacts of a phase, down to one short file for Idea and Blueprint together. A tier MUST NOT remove a phase’s decision or an owner gate.

The gates

  • R4. G0 Bet. The owner MUST decide go or no-go, the appetite (the time the owner will invest, in agent-days or working days) and the tier before Blueprint work starts. The input is a one-page Vision and a pitch that states the appetite; the decision MUST be recorded in a file, with its date.
  • R5. G1 Blueprint approved. The owner MUST approve the scope and every ADR marked owner-level before Build starts for the first time. At the standard tier and above, an independent architecture review of the Blueprint (arch.architecture-review) MUST precede the gate and its verdict MUST be shown to the owner.
  • R6. G2 Ready. The lead MUST decide that a release is ready for Build, against the Definition of Ready (process.definition-of-ready, copied from templates/definition-of-ready.md). The owner MUST decide instead when the release spec changes the scope or the appetite, or needs an owner-level decision.
  • R7. Build. Each work package (process.work-packages) MUST meet the Definition of Done (process.definition-of-done, copied from templates/definition-of-done.md) before it is merged. At the standard tier and above, someone other than the builder MUST verify it (mgmt.governance-tiers#R7).
  • R8. G3 Go-live. The owner MUST approve going live with production of a live or client system, and any irreversible step, unless a standing rule of the owner (mgmt.roles-and-decision-rights#R17) names that action. An approval of the release against its checklist (quality.quality-release#R14) does not replace this approval. The evidence MUST be the release candidate, the verification results and a rollback that was tested or rehearsed; what the rollback plan contains is set by quality.quality-release#R13.
  • R9. Hand-over to Support. A system MUST pass a production readiness review before Support takes it over (the checklist ops.production-readiness-and-handover): a runbook, backups proved by restore, monitoring and a named contact. The lead decides; the owner sets who supports the system (a development team or a support team).

Change classes

  • R10. Every piece of work that arrives while a system is in Support MUST be given a class and the class MUST be recorded with the work. A fix goes straight to Build. A change goes through a short release spec. A system change goes back to Blueprint. When the class is in doubt, the higher class MUST be taken.

Backups and live systems

  • R11. When work changes a live system, a backup proved by restore MUST exist before the first change. This is an entry condition of Build, and it comes in addition to the pre-release backup of quality.quality-release#R17 and the pre-change backup of ops.backups#R4. “Proved by restore” means a restore test of this backup as ops.backups#R6 describes. At the least, where a full restore of the system is not practicable, the database dump MUST be loaded into a separate database and read, the file archive MUST be listed, and the result MUST be recorded. A system that is not yet live takes its first backup before its first deployment.
  • R12. Changes to a live system MUST be built and verified on a staging copy. Using the live system as a test bed is an exception that MUST have a project ADR (arch.adr) that names the owner as approver, says why staging is not used and gives the rollback. Without such an ADR, the staging rule holds. A change that touches no code and whose rollback cannot go wrong, such as switching the runtime version in a hosting panel or editing a crawler-rules file, is a fix that needs no staging copy and no ADR; R11 still applies to it.

Recall and record

  • R13. Every phase MUST open with a recall step and close with a record step. Recall looks for earlier work that bears on this phase, with the project’s memory tools (today a search over the project’s files and the agents’ session memory files). Record writes down what the phase decided and what it learned. Every gate checklist MUST ask whether both were done.
  • R14. Recall informs a decision and never makes it. Anything normative that recall finds, or that a record produces, MUST be put in a file in the project’s repository. An outcome that repeats MUST be promoted: from memory to a knowledge-base entry or a Hub item, and from there to a check.

Mapping existing procedures

  • R15. A procedure that has its own list of stages MUST map each of its stages to one main phase of this item, MUST name in a note any other phase the stage touches, and MUST keep the order of the phases. A stage that fits no phase shows that the procedure or this item is incomplete, and MUST be reported as a finding.

Guidance

The spine

The six phases are the owner’s own words. The nine stages of the Hub directive (discovery, requirements, architecture, planning, implementation, verification, release, operation, evolution) are activities inside them.

Phase Question Output Exit gate Who decides
Idea Why, for whom, and is it worth the appetite? Vision; a pitch with the appetite; a tier proposal G0 Bet: go or no-go, appetite, tier Owner
Blueprint What must it do, and how is it built? PRD, Blueprint, ADRs, Roadmap, open questions; an independent architecture review at the standard tier and above G1 Blueprint approved: the scope and every owner-level ADR Owner, with the review verdict
Spec What exactly does this release change, and how will we know it works? Release spec; the checks to add first; work packages G2 Ready: the Definition of Ready is met Lead; the owner only when scope or appetite changes or an owner-level decision is needed
Build Is each change done and verified? Merged work packages, green checks, review reports Definition of Done, per package Lead and the automated gate
Release Can it ship safely? Release candidate, verification evidence, a tested rollback, the release record G3 Go-live: production of a live or client system, or any irreversible step Owner, or under a standing rule (mgmt.roles-and-decision-rights#R17)
Support Is it reliable, and how does it change safely? Runbook, service levels in small form, backups proved by restore, incident and postmortem records, change intake Hand-over passes the production readiness review Lead; the owner sets the placement
Retire (optional) How is it switched off? Retirement plan, data export or deletion none Owner

Idea and Blueprint run once, and again for a system change. Then the project loops Spec, Build and Release once per release and lives in Support in between. The Spec phase is described by the release spec item and Build by the work-packages item (process.work-packages, with process.definition-of-ready and process.definition-of-done); Support by ops.production-readiness-and-handover, ops.service-levels and ops.incidents-and-postmortems; until the release items exist, the gates point to the existing templates for release (templates/release-checklist.md, templates/run-record.md).

What each gate asks

Each checklist below also asks for the recall step and the record step of its phase (R13).

  • G0 Bet. Is there a one-page Vision? Is the appetite stated, with what is left out if it is reached? Is the tier proposed with its reason? Have similar past projects and their hours been looked at? Is the decision, with its date, in a file?
  • G1 Blueprint approved. Does the Blueprint cover every requirement, or say “deferred” for it? Is each hard-to-reverse choice an ADR, and is each owner-level one marked? Did an independent review report, and is every High finding closed or accepted by the owner? Do the dead ends from research appear in the record?
  • G2 Ready. Does the release spec state goals and non-goals? Are the checks to add first named? Is the rollback written? Does the total of work packages fit the appetite? Are open questions given a default?
  • G3 Go-live. Is the candidate the one that was verified, with its checksum? Was the backup proved by restore? Was the rollback tested? Is this the owner’s gate, and has the owner said yes in writing, or does a standing rule name this action?
  • Hand-over. Is there a runbook that a person who did not build the system can follow? Do backups restore? Who is the contact? Are the service levels, in small form, stated?

Change classes

Class What it looks like Route What it needs
Fix A defect against stated behaviour; a configuration or content correction; no new behaviour Build, then Release A failing check first, the backup of R11, the regression test
Change New or altered behaviour inside the existing Blueprint A short release spec, then Build and Release The release spec, the checks to add first, a rollback
System change A new platform, a new external interface, a new data store, a change of tier or of an owner-level ADR Back to Blueprint, then the full loop A Blueprint revision, new or superseding ADRs, the owner’s G1

When a fix grows during work (a second system is touched, data must be migrated), stop and re-classify it.

The two rules in practice

Backup before Build. In an old procedure the backup stood just before deployment. For a live system that is too late: the first edit can already do harm, such as a plugin update or a hand edit of a database. So the backup, and its restore test, moves to the entry of Build. The pre-release backup still applies and is taken again, because the data moves on between the two. For a new system that has no users and no data worth keeping, nothing is lost by editing, so its first backup comes before its first deployment.

Live system as a test bed. Sometimes there is no staging copy: the system cannot be cloned, or the fault shows only under real traffic. The exception is then written down before the work, as an ADR with the sections below. The owner approves it, not the lead.

  1. The system, the owner as approver, and the date.
  2. The reason staging is not used, and what was tried.
  3. What can go wrong, and for whom.
  4. The rollback, with its trigger, steps and time.
  5. The backup of R11 and where it is kept.

Recall and record in each phase

Phase Recall at entry Record at exit
Idea Have we built something like this? Past cases, hours and sums. The bet and the appetite (file). Why rejected options were rejected (outcome).
Blueprint Earlier ADRs and known pitfalls for this platform and these interfaces. ADRs (file). Dead ends met in research (outcome).
Spec Outcomes of similar changes; estimates against actuals. The release spec (file). Assumptions taken as defaults (outcome).
Build The ADR or contract that governs this code, instead of re-reading every document. Surprises, failed attempts and workarounds (outcome); lines for the playbook.
Release The last release’s lessons and rollback notes. The release record (file); delivery data points.
Support Past incidents on this system. The postmortem (file); every escaped defect becomes a new check.

“File” means a document in the repository. “Outcome” means a note of what was tried and what happened, kept where the project keeps its memory until it is promoted to a file.

Tailoring by tier

The tier definitions have one home, mgmt.governance-tiers; this item says only what the phases do with them. At the lightweight tier, Idea and Blueprint can be one short file and G1 is the owner’s approval of that file; the release spec can be a section of the issue. At the standard tier, each phase has its own artefact and G1 follows an independent review. At the high-assurance tier, a second reviewer checks the Blueprint and each release. At every tier, G0, G1 and G3 stay with the owner.

The tier item says the same in its own rules: a rollback that was tested or rehearsed before G3 at every tier (mgmt.governance-tiers#R10), and an independent architecture review before G1 at the standard tier and above (mgmt.governance-tiers#R7).

How the existing procedures map onto the phases

Every stage of the Hub’s three playbooks, of the UASK web-delivery workflow (stages 0 to 10), of the UASK support delivery rules (stages 0 to 7) and of the two outside lifecycles the Hub borrows from is listed once. Where a stage fits two phases, the row names the main one and the note names the other and says why.

GOV.UK service phases and the Hub directive’s nine stages

Source stage Phase Note
GOV.UK Discovery Idea
GOV.UK Alpha Blueprint
GOV.UK Beta Build Beta is iterations; each iteration also touches Spec and Release
GOV.UK Live Support
GOV.UK Retirement Retire
Directive: Discovery Idea
Directive: Requirements, Architecture Blueprint
Directive: Planning Blueprint Also Spec: the Roadmap belongs to Blueprint; the plan of one release belongs to Spec
Directive: Implementation, Verification Build
Directive: Release Release
Directive: Operation, Evolution Support Evolution arrives as a class (R10)

The Hub’s playbooks

Playbook stage Phase Note
Project foundation 1 Intake, 2 Vision Idea Stage 1 records the owner’s go or no-go, the appetite and the tier; this is G0 (mgmt.project-foundation#R15)
Project foundation 3 Requirements, 4 Research, 5 Blueprint, 6 Decisions, 7 Roadmap and issues Blueprint
Project foundation 8 Repository bootstrap Blueprint Done before G1, so that Build can start on a ready repository
Project foundation 9 Owner approval gate Blueprint (exit) This is G1
Architecture review 1 to 8 (intake, evidence, as-is, quality goals, analysis, findings, target, report) Blueprint The review of an existing system feeds a system change, or a re-foundation, and ends at G1
Architecture review 9 Follow-up Support The findings become classified work (R10)
Quality and release 1 Set up Build Done once, at the entry of the first Build
Quality and release 2 Build a change Build
Quality and release 3 Prepare the release, 4 Back up and deploy, 5 Verify, 6 Close Release Stage 4’s backup does not replace the earlier backup of R11
Quality and release 7 Hotfix Release A fix (R10): it goes through Build, then the shortened lane of Release

The UASK web-delivery workflow (a new site, or a rebuild)

Workflow stage Phase Note
0 Intake of the order Idea
1 Hosting reconnaissance Idea Read-only; it is the recall step of Blueprint when the site already exists
2 Digest of the client’s terms of reference Idea The terms of reference stay an input; the PRD takes their content
3 Gaps and questions Idea
4 Scope, stages and estimate Blueprint Also Spec: the scope and estimate are Blueprint (G1); the plan of a release is Spec
5 Platform and environment Blueprint
6 Build Build
7 Backup before the first deployment Release The first backup of a system that is not yet live (R11), which the workflow also takes once, right after the platform is installed; on a live site it moves to the entry of Build
8 Launch Release G3
9 Acceptance Release
10 Hand-over to support Support The hand-over of R9

The UASK support delivery rules (work on a live site)

Rules stage Phase Note
0 Reconnaissance Idea For a fix this is intake, not Idea; where the project already exists it is the recall step of Spec; the class of the work is set here
1 Fixing the scope (the plan of the work) Spec The release spec of a change, or the plan of a fix
2 Backup Build The entry condition of R11
3 Staging Build The staging rule of R12
4 Work Build
5 Release in a window Release G3 where the owner’s standing rules call for it
6 Acceptance Release
7 Close Release The close of this piece of work, like Close in the release playbook: its record step (the case, the lessons, the entry in the site’s own knowledge base); the system then stays in Support

No stage of the procedures above is left without a phase. A new stage list that cannot be mapped is a finding under R15.

Explanation

Why six phases. The set follows the phases of public-service delivery (GOV.UK: discovery, alpha, beta, live, retirement), with two changes. Alpha and beta are not one phase each: the Hub has a Blueprint that is approved once and a loop of releases, because a small team ships many releases against one architecture. And Idea and Blueprint are separate so that the owner can say no before an architecture is written; Shape Up makes the same cut with a bet at the end of shaping, and the appetite comes from there: time is fixed, scope is varied.

Why three owner gates. The owner’s time is the scarce resource. G0, G1 and G3 are the points where a wrong decision is expensive and cannot be taken back cheaply: what to build, what shape it takes, and when it meets real users. Everything else is decided by the lead and logged. G3 follows the launch discipline of site reliability engineering (a launch checklist, and a readiness review before a service is handed to those who run it), though the Hub keeps the owner at G3 and gives the readiness review to the hand-over.

Why change classes. Without a class, every request pays the whole process or none of it. A fix pays almost nothing, a change pays a short release spec, and a system change pays a Blueprint. Taking the higher class when in doubt costs a little time; taking the lower one costs a live system.

Why the backup moved. Three older procedures disagreed on where the backup goes: before the first deployment, before the work, or before the release. All three were right for some case. The rule picks the strictest for a live system, because the risk starts at the first edit, and the plainest for a new system, because there is nothing to lose yet. The phrase “proved by restore” is kept from the support practice: a backup that was never read back is not yet a backup.

Why the test bed is an exception. Some work can only be tried on the real system. Forbidding it would push people to do it quietly. Allowing it silently would remove the safety of staging. A written exception, approved by the owner and with a rollback, makes the risk visible and puts the decision where the harm would land.

What this item does not do. It does not define roles and decision rights in full, the release spec, the architecture description or the work-package rules. Those are separate items. It names the phases and gates so that they can refer to one another.

Examples

Good. A small shop-theme project at the standard tier. The owner records G0 in an issue: go, ten agent-days, standard tier. The lead writes the Vision, PRD, Blueprint and two ADRs; an independent session reviews them; the owner approves the scope and the one owner-level ADR at G1. For release 1.1 the lead writes a release spec, checks the Definition of Ready and starts Build. Because the site is already live, the lead takes a backup of the files and database, restores it on a spare account, and records the check before the first edit. At G3 the owner approves the deployment to production; the hand-over to support follows its production readiness review. A later request, “the checkout button is misaligned on phones”, is a fix: it goes to Build with a failing check first. “Add a second payment provider” is a change with a short release spec. “Replace the shop platform” is a system change and goes back to Blueprint.

Bad. A team fixes a payment bug on the live system “just this once”, without a staging copy and without a backup, and calls the work a fix. The edit locks a table and orders are lost for an hour. Three rules were broken: the backup came after the first edit (R11); the live system was the test bed with no ADR (R12); and a change to the payment flow was taken as a fix when the class was in doubt (R10).

Sources

  • GOV.UK Service Manual, “Agile delivery” — Open Government Licence v3.0; the phases discovery, alpha, beta, live and retirement. Accessed 2026-11-21.
  • SWEBOK Guide v4.0 — all rights reserved; cited as a map of the topics, not copied. Accessed 2026-11-21.
  • Ryan Singer, “Shape Up” — all rights reserved; the ideas of appetite, betting and the circuit breaker are paraphrased, not copied. Accessed 2026-11-21.
  • Google, “Site Reliability Engineering” — CC BY-NC-ND 4.0; cited only: chapter 27 (the launch checklist) and chapter 32 (the production readiness review). Accessed 2026-11-21.
  • ISO/IEC/IEEE 12207:2017 (software life cycle processes) — referenced by name only.