Feature Lifecycle
Core Philosophy: If a movie doesn't have a budget and constraints, nothing gets finished.
This is a feature-level framework. Each feature flows through the pipeline independently. At any point in a project, you'll have multiple features at different stages — some in discovery, some in design, some being built, some in QA.
Why This Framework Exists
The "Who Fed the Dog?" Problem
Without clear ownership, things fall through the cracks. Everyone assumes someone else handled it. The dog doesn't get fed.
This framework solves that by making ownership explicit:
- Each stage has an owner.
- Each transition has requirements.
- If requirements aren't met, the feature doesn't move.
No ambiguity. No assumptions. No unfed dogs.
Department Ownership
| Stage | Owner | Responsible For |
|---|---|---|
| Backlog | PM | Prioritization, scoping requests |
| Todo | PM | Weekly planning, assignments |
| Discovery In Progress | PM / Design | Requirements, user flows |
| Ready for Design | Design | Picking up scoped work |
| Design In Progress | Design | Wireframes, UI, prototypes |
| Design In Review | Design + PM | Client feedback, revisions |
| Ready for Engineering | Engineering + PM | Ensuring ticket is complete |
| Engineering In Progress | Engineering | Building per spec |
| Engineering In Review | Engineering | Code review, merging |
| Ready for QA | QA / Engineering | Testing, bug tickets |
| Done | PM | Release coordination |
The rule: You own your stage. You're responsible for exit criteria.
If a feature is stuck, look at who owns that stage. That's who's responsible for moving it forward.
No Skipping Stages
Every feature follows the same path. No exceptions.
- A "simple" feature still needs discovery.
- A "quick fix" still needs design review.
- An "urgent" request still needs QA.
The moment you skip a stage, you create inconsistency. Inconsistency creates confusion. Confusion creates unfed dogs.
Replicability Over Heroics
This framework is designed to be repeatable across any project, any client, any team size.
Why replicability matters:
- New team members can onboard by learning one process
- Any project follows the same structure
- Handoffs are clean because everyone knows the stages
- Estimation improves because the process is predictable
- Quality stays consistent because nothing gets skipped
We don't rely on heroes who "just know" what to do. We rely on a process that works every time.
The Contract Between Departments
PM → Design: "I will give you scoped requirements and user flows before asking for designs."
Design → Engineering: "I will give you approved designs with acceptance criteria before asking you to build."
Engineering → QA: "I will give you working code deployed to staging before asking you to test." (we don't have QA rn so engineering and PM will test together on an agreed environment)
QA → PM: "I will give you verified features with no critical bugs before you release."
⚠️ Break this contract, and the pipeline breaks.
Sales / Estimates (WIP)
| Plan | Product Size | Design & Discovery | Engineering |
|---|---|---|---|
| Plan A | Mid-size (1 main feature, 2 sub features) | 2 months | 2 months |
| Plan B | Accelerated | 1 month | 1 month |
| Plan C | Large-size product (1+ main features, 2+ sub features) | 2 months | 4 months |
Feature Lifecycle
Every feature flows through these stages independently:
Backlog (someday)
↓
Todo (this week, to be decided on monday meetings)
↓
Discovery In Progress
↓
Ready for Design
↓
Design In Progress
↓
Design In Review
↓
Ready for Engineering ← Feature is "funded" — engineering can start
↓
Engineering In Progress
↓
Engineering In Review (PR being reviewed)
↓
Ready for QA
↓
Done
The gate: A feature cannot move to Ready for Engineering without designs attached and approved.
Backlog & Planning
Backlog
The parking lot. Features live here until they're prioritized for an upcoming week.
What lives here:
- Client requests
- Ideas and improvements
- Future release features
- Low priority items
Features stay in Backlog until:
- Prioritized for a release
- Scheduled for an upcoming week
Todo
This week's work. Features here are actively being worked on or will be picked up this week.
To enter Todo:
- Prioritized from Backlog
- Assigned to someone
- Scope is clear enough to start
To exit Todo:
- Assigned to discovery
- Work has started
Discovery
Discovery In Progress
PM/Design is researching and scoping the feature.
Work happening:
- User flow mapping
- Requirements gathering
- Technical feasibility check with engineering
- Stakeholder alignment
To exit Discovery:
- Requirements documented
- User flows complete
- Ready for design work
Ready for Design
Feature is scoped and waiting for a designer to pick it up.
Design
Design In Progress
Designer is actively working on the feature.
Work happening:
- Wireframes (low → high fidelity)
- UI designs
- Interactive prototypes
- Design system components
Design In Review
Designs are complete and awaiting approval.
To exit Design In Review:
- Designs attached to ticket
- Client feedback received
- Revisions complete
- Final approval from client/PM
Ready for Engineering
This is the "funded" state. The feature has everything engineering needs to build.
A feature in Ready for Engineering must have:
- Designs attached
- Acceptance criteria defined
- Edge cases documented
- Dependencies identified
🚫 No feature reaches this state without designs. This is the rule.
Engineering
Engineering In Progress
Developer is actively building the feature.
Work happening:
- Implementation per designs
- Unit tests
- Integration tests
Engineering In Review
Code is complete. Pull request is being reviewed.
To exit Engineering In Review:
- PR approved
- Code merged
- Deployed to staging
Ready for QA
Feature is built and deployed to staging, waiting for testing.
QA
Ready for QA
QA/team is testing the feature on staging.
Work happening:
- Functional testing against acceptance criteria
- Edge case testing
- Performance testing
- Bug tickets created for issues found
To exit Ready for QA:
- All acceptance criteria verified
- No critical bugs open
- Ready for production
Done
Feature is verified and deployed to production. Ticket closed.
Releases
Features are batched into releases. A release ships when all its features reach Done.
┌─────────────────────────────────────────────────────────┐
│ RELEASE 1 │
│ │
│ Feature A: Done ✓ │
│ Feature B: Done ✓ │
│ Feature C: Done ✓ │
│ │
│ → Ship Release 1 │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ RELEASE 2 │
│ │
│ Feature D: Engineering In Progress │
│ Feature E: Design In Review │
│ Feature F: Ready for Engineering │
│ │
│ → Not ready to ship │
└─────────────────────────────────────────────────────────┘
Release Checklist
Before a release can ship:
- All features for this release are Done
- No critical bugs open
- Staging tested and approved
- Client sign-off received
- Rollback plan documented
Mid-Project Feature Requests
When a client requests a new feature mid-project:
- Create ticket → Goes to Backlog
- Prioritize → Move to Todo when ready to start
- Flow through pipeline → Same stages as every other feature
- Ship when ready → Either with planned release or next release
New features don't skip stages. They start at Backlog and earn their way to Ready for Engineering like everything else.
Pipeline View (Example)
At any point, your board might look like this:
| Stage | Features |
|---|---|
| Backlog | Feature H, Feature I, Feature J |
| Todo | Feature G |
| Discovery In Progress | Feature F |
| Ready for Design | Feature E |
| Design In Progress | Feature D |
| Design In Review | — |
| Ready for Engineering | Feature C |
| Engineering In Progress | Feature B |
| Engineering In Review | Feature A |
| Ready for QA | — |
| Done | (Release 1 features) |
Multiple features moving through simultaneously. Each at its own pace. Each following the same rules.
Weekly Planning
Each week, pull features from Backlog into Todo based on:
- Release priorities
- Team capacity
- Dependencies
- Client urgency
Backlog = someday
Todo = this week
Quick Reference
The Gates
| From | To | Requirements |
|---|---|---|
| Backlog | Todo | Prioritized + assigned + scope clear |
| Todo | Discovery In Progress | Work started |
| Discovery In Progress | Ready for Design | Requirements + user flows documented |
| Design In Review | Ready for Engineering | Designs attached + approved |
| Engineering In Review | Ready for QA | PR merged + deployed to staging |
| Ready for QA | Done | Acceptance criteria verified |
Release Planning
| Release | Features | Target Date | Status |
|---|---|---|---|
| Release 1 | |||
| Release 2 | |||
| Release 3 |