Project lifecycle, gates and change classes
- Status
- Approved
- Version
- 0.2.8
- Authority
- UASK standard
- Applies to
- Core
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 fromtemplates/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 fromtemplates/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 byquality.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#R17and the pre-change backup ofops.backups#R4. “Proved by restore” means a restore test of this backup asops.backups#R6describes. 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.
- The system, the owner as approver, and the date.
- The reason staging is not used, and what was tried.
- What can go wrong, and for whom.
- The rollback, with its trigger, steps and time.
- 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.