All 14 original diagrams, with eight wheel stages and 730 rectangular regions. Original source labels and normalized guidance are distinguished. Suggested measures and dashboard values are examples, not live data.
Return to interactive diagramsNormalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Inputs and outputs transcribed from this artwork; question, actions, gate and measures use the normalized reference.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What problem are we solving?
Is the opportunity sufficiently validated?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Define
What should we build and why?
Is the proposed investment and scope justified?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Design
How should the product work and feel?
Is the solution usable, feasible, and ready to build?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Build
Can we turn the plan into a working product?
Does the increment meet agreed acceptance criteria?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Validate
Does it work correctly and solve the problem?
Are quality, risk, and acceptance criteria met?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Launch
How do we get it into users’ hands?
Is the launch stable and meeting initial expectations?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Improve
What should we improve based on learning?
Are improvements delivering measurable value?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Scale / Maintain
How do we grow, sustain, or sunset it?
Should we expand, maintain, modernize, or retire?
Question, responsibility and deliverables transcribed from the artwork; gate and suggested measures use the reference model.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
PM responsibility transcribed from this artwork; other detail fields use the normalized reference.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Deliverables transcribed from this artwork; supporting explanation uses the normalized reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source stage: Idea
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Minimal involvement
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Minimal involvement
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Primary owner
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Minimal involvement
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Minimal involvement
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Minimal involvement
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Minimal involvement
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Minimal involvement
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Minimal involvement
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source stage: Idea
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Minimal involvement
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Primary owner
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Primary owner
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Primary owner
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Minimal involvement
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Minimal involvement
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Minimal involvement
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Minimal involvement
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Minimal involvement
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Minimal involvement
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Minimal involvement
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Contributor
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Primary owner
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Idea
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Research
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
Source stage: Validation
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: Strategy
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Define
Source stage: MVP Scope
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Requirements
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Design
Source stage: Architecture
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Build
Source stage: Build
Source involvement: Primary owner
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: Test
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Validate
Source stage: UAT
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Launch
Source stage: Launch
Source involvement: Minimal involvement
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Feedback
Source involvement: Minimal involvement
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Improve
Source stage: Optimize
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Scale
Source involvement: Minimal involvement
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Scale / Maintain
Source stage: Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Team/stage axes and participation read from the original matrix dot fill; activity, input and output use the normalized team reference.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Inputs, activity and outputs transcribed from this workflow; gate and measures use the normalized phase reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
Source involvement: Minimal involvement
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
Source involvement: Minimal involvement
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source involvement: Primary owner
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
Source involvement: Primary owner
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
Source involvement: Contributor
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
Source involvement: Primary owner
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Source involvement: Minimal involvement
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
Source involvement: Minimal involvement
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
Source involvement: Minimal involvement
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
Source involvement: Contributor
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
Source involvement: Primary owner
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Source involvement: Primary owner
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
Source involvement: Minimal involvement
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
Source involvement: Contributor
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
Source involvement: Primary owner
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
Source involvement: Contributor
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
Source involvement: Minimal involvement
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
Source involvement: Minimal involvement
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
Source involvement: Minimal involvement
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
Source involvement: Contributor
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Source involvement: Contributor
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
Source involvement: Primary owner
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
Source involvement: Contributor
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
Source involvement: Primary owner
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Role names transcribed from this artwork; supporting contribution uses the team reference.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Illustrative values printed in the original artwork, not live portfolio performance.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Illustrative values printed in the original artwork, not live portfolio performance.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Illustrative values printed in the original artwork, not live portfolio performance.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Normalized phase reference; original stage label retained.
Normalized phase: Build
How do we deliver a reliable product?
Does the increment meet agreed acceptance criteria?
Illustrative values printed in the original artwork, not live portfolio performance.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Illustrative values printed in the original artwork, not live portfolio performance.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Illustrative values printed in the original artwork, not live portfolio performance.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Illustrative values printed in the original artwork, not live portfolio performance.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Illustrative values printed in the original artwork, not live portfolio performance.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Launch
How do we launch and enable adoption?
Is the launch stable and meeting initial expectations?
Normalized phase reference; original stage label retained.
Normalized phase: Discover
What customer problem is worth solving?
Is the opportunity sufficiently validated?
Normalized phase reference; original stage label retained.
Normalized phase: Define
What should we build, and why now?
Is the proposed investment and scope justified?
Normalized phase reference; original stage label retained.
Normalized phase: Design
How should the solution work?
Is the solution usable, feasible, and ready to build?
Normalized phase reference; original stage label retained.
Normalized phase: Validate
Does the product solve the problem safely and reliably?
Are quality, risk, and acceptance criteria met?
Normalized phase reference; original stage label retained.
Normalized phase: Scale / Maintain
How do we sustain and grow product value?
Should we expand, maintain, modernize, or retire?
Normalized phase reference; original stage label retained.
Normalized phase: Improve
What can we learn and improve?
Are improvements delivering measurable value?
Normalized phase reference; original stage label retained.