02 Five-stage model
The 5-Stage Model
One loop from uncertain input to deliberate production. Watch the path; Execute is the engine.
The Flow
How the Model Works
Work flows from ambiguous inputs through rapid execution to validated solutions, which are judged at a governance gate before deliberate production.
Critical Sequence: Governance Comes After Solution
Note that the Governance Gate comes after the Solution stage, not between Execute and Solution. This is intentional: multiple solutions emerge from Execute, and governance judges which solutions advance to production. Solutions are "realized strategy examples"—testable candidates ready for judgment, not final conclusions.
Stage One
Input
The catalyst that triggers execution. Inputs can be detailed research findings or simply a "what if" statement. They don't need to be perfect to start—their value is determined by how effectively they're exercised through execution.
Types of Inputs
- Research insights: User needs, pain points, behavioral patterns
- Strategic direction: Business goals, market opportunities
- Hunches: Intuition, pattern recognition, creative ideas
- Requirements: Feature requests, technical constraints
- Design system: Tokens, components, patterns (critical constraint)
Key Characteristics
- Variable quality and completeness
- Don't need to be perfect to start
- Can be singular or multiple
- May evolve during Execute stage
Who's Involved
- Product strategists (define inputs)
- UX researchers (provide insights)
- Business stakeholders (share goals)
- Design system stewards (provide constraints)
Success Criteria
- Clear enough to begin execution
- Constrained enough to stay on-brand
- Open enough to allow exploration
Example Input
"User research shows that 73% of our users abandon the onboarding flow at step 3. They're confused about which plan to choose. We need to simplify the decision and reduce cognitive load. Use our existing card components and pricing table from the design system."
Stage Two — THE HEART
Execute
The prime value creation stage of EEM. This is where ideas come to life through rapid experimentation. Designers direct AI agents to build functional prototypes, iterate rapidly, and explore multiple solution variants.
Execute is the heart of EEM. This is where uncertainty collapses through making, not planning.
What Happens Here
- Agent IDE workflows (Cursor, Windsurf, Bolt)
- Designers direct, AI agents build
- Functional prototypes created (not theater)
- Multiple solution variants explored simultaneously
- Stakeholder review of working software
Key Principles
- Speed matters—make to learn
- Fidelity chosen deliberately
- Failure is learning (experiments can fail)
- Multiple solutions better than single "perfect" one
Stage Three
Solution
Multiple validated solution variants emerge from Execute. Each is a "realized strategy example"—a testable, functional experiment ready for judgment. These are not conclusions; they're options.
Key Characteristics
- NOT a single "final" output
- Multiple variants (2-5 typically)
- Functional and demonstrable
- Tested with stakeholders
- Documented with learnings
What Solutions Include
- Working prototypes (code-based)
- Documentation of approach
- Stakeholder feedback captured
- Technical feasibility assessment
- Known trade-offs documented
Who's Involved
- Execution designers (present solutions)
- Product strategists (synthesize learnings)
- Stakeholders (provide final input)
- Engineering (preliminary feasibility)
Success Criteria
- Solutions answer the original input
- Variants show different strategic choices
- Trade-offs are understood
- Ready for judgment
Stage Four
Governance Gate
Human judgment determines which solution(s) advance to production. This is where prioritization, quality verification, and handoff happen. Governance MUST exist—this is non-negotiable.
Framework Position: Governance must happen (non-negotiable), but how it happens is team-specific (agnostic).
Critical Functions
- Selection: Which ship? Which iterate? Which reject?
- Prioritization: What ships first? What waits?
- Quality verification: Brand, technical, UX quality
- Risk assessment: Security, compliance, business
- Design system evolution: New patterns identified?
Quality Gates
- Does it solve the user need? (evidence required)
- Does it align with brand? (compliance check)
- Is handoff documentation complete?
- Did it create new patterns? (system update needed?)
Handoff is Shared Responsibility
Design team prepares handoff documentation (specs, edge cases, system updates).
Engineering team accepts or rejects handoff readiness.
Stage Five
Production
Production is NOT the default outcome of activity. It's a deliberate commitment after governance. Only validated solutions that have earned confidence through execution ship to users.
Production is deliberate. Risk has been surfaced, trade-offs understood, teams commit with clarity.
What Happens
- Engineering builds production-ready implementation
- May refine/optimize validated solution
- Maintains brand/UX intent from solution
- Deploys to users
Key Principles
- Not the default outcome of activity
- Deliberate commitment after governance
- Risk has been surfaced and addressed
- Trade-offs are understood
Closing the Loop
The Feedback Loop
Production outcomes become new inputs. This closes the loop and enables continuous learning.
Usage Analytics
How are users actually using what shipped?
User Feedback
What are users saying? What patterns emerge?
System Health
Design system updates, pattern usage, consistency.
Learning Docs
What worked, what didn't, what to try next.
These outputs feed back into the Input stage, triggering new execution cycles. The model is continuous, not linear.
Ready to Implement This Model?
The 5-stage model provides structure without rigidity. Let's discuss how it applies to your team's context.
Explore deeper: