Version: 1.0
Date: 2026-06-11
Status: Kanban board with 31+ stories ready for implementation
The TWAIN backlog is organized into 8 epics across 16-18 weeks (1 FTE) or 8-10 weeks (2 FTE).
GitHub Project: https://github.com/orgs/washu-dev/projects/13
Repository: https://github.com/washu-dev/TWAIN
| # | Epic | Stories | Effort | Priority | Critical Path | Status |
|---|---|---|---|---|---|---|
| 1 | Schemas | 6 stories | 2w | P0 | YES | Ready |
| 2 | Control Plane | 5 stories | 2w | P0 | YES | Ready |
| 3 | Researcher UX | 3 stories | 2w | P1 | YES | Ready |
| 4 | Discovery & Planning | 4 stories | 2.5w | P1 | YES | Ready |
| 5 | Code Gen & Execution | 3 stories | 2w | P1 | YES | Ready |
| 6 | Validation & Correction | 3 stories | 2w | P2 | YES | Ready |
| 7 | Provenance & Governance | 3 stories | 2w | P2 | YES | Ready |
| 8 | Chemistry Pilot | 4 stories | 2w | P3 | YES | Ready |
| TOTAL | — | 31+ stories | 16–18w | — | — | ✅ |
- Epics 1 & 2: Schemas and Control Plane
- Must complete first: Lock schemas early, unlock parallel work
- Estimated duration: 4 weeks (Phases 1-2)
- Action: Staff 1 senior engineer + 1 mid-level engineer on these epics
- Epics 3, 4, 5: UX gates, discovery/planning, code gen & execution
- Can start after: Phases 1-2 complete
- Estimated duration: 5-6 weeks (Phases 3-5, can parallelize)
- Action: Assign 2-3 engineers after Epic 2; can work in parallel
- Epics 6 & 7: Result validation, self-correction, provenance, governance
- Can start after: Phase 5 (code execution working)
- Estimated duration: 4 weeks (Phases 6-7)
- Action: Assign 1-2 engineers
- Epic 8: Chemistry pilot, end-to-end validation, demo
- Can start after: All prior epics substantially complete
- Estimated duration: 2 weeks (Phase 8)
- Action: Assign 1 engineer + chemistry domain expert
- Schema definition stories
- Simpler modules
- Most control plane stories
- Integration components
- Complex state machines
- Code generation and planning
- Validation loops
The GitHub Project board uses 5 columns (no sprints):
- 📋 Backlog — Not yet started; waiting for dependencies
- 🎯 Ready — Dependencies met, ready for eng to pick up
- 🚀 In Progress — Actively being worked on
- 🔍 In Review — Code review in progress
- ✅ Done — Merged, tests pass, validated
Flow: Backlog → Ready → In Progress → In Review → Done
Stories: 1.1 → 1.2 → 1.3 → 1.4 → 1.5 → 1.6
Blocks: Everything else
Assign to: 1-2 senior/mid-level engineers (pair recommended)
Stories: 2.1 → 2.2 → 2.3 → 2.4 → 2.5
Blocks: UX, discovery, execution
Depends on: Epic 1
Assign to: 1 senior engineer (distributed systems expertise)
Stories: 3.1 → 3.2 → 3.3
Enables: approval gates
Depends on: Epics 1, 2
Assign to: 1 mid-level engineer
Can parallelize with: Phase 4
Stories: 4.1 → 4.2 → 4.3 → 4.4
Enables: tool discovery, cost estimation
Depends on: Epics 1, 2, 3
Assign to: 1 mid-level engineer
Can parallelize with: Phase 3
Stories: 5.1 → 5.2 → 5.3
Enables: first end-to-end run
Depends on: Epics 1, 2, 4
Assign to: 1 senior + 1 mid-level engineer
Stories: 6.1 → 6.2 → 6.3
Enables: result interpretation, auto-correction
Depends on: Epics 1, 5
Assign to: 1 mid-level engineer
Stories: 7.1 → 7.2 → 7.3
Enables: audit trail, policy enforcement
Depends on: Epics 1, 2, 5, 6
Assign to: 1 senior engineer (governance/security expertise)
Stories: 8.1 → 8.2 → 8.3 → 8.4
Enables: demo, validation
Depends on: All prior epics
Assign to: 1 mid-level engineer + chemistry domain expert
Scenario A: 1 FTE (18 weeks)
- 1 senior full-stack engineer
- Phases execute sequentially
- Good for: proof-of-concept, learning the codebase
Scenario B: 2 FTE (9-10 weeks) ⭐ RECOMMENDED
- 1 senior engineer (Epics 1, 2, 5, 7)
- 1 mid-level engineer (Epics 1, 3, 4, 6, 8)
- Phases 1-2 sequential, Phases 3-7 overlap
- Good for: MVP timeline, balanced team
Scenario C: 3 FTE (6-7 weeks)
- 1 senior (architecture, control plane)
- 2 mid-level (discovery/planning, code gen/execution, validation/governance in parallel)
- Aggressive, requires strong async communication
A story is Ready when:
- Dependencies are met (all blocked-by issues are Done)
- Acceptance criteria are clear and testable
- Effort estimate is documented
- Module paths and file names are specified
- Test plan is outlined
A story is Done when:
- Acceptance criteria all marked complete (☑)
- Code is written and reviewed
- Unit tests pass (>80% coverage)
- Integration tests pass (if applicable)
- Schemas validate (if applicable)
- Documentation updated
- PR merged to main
Track these metrics throughout implementation:
| Metric | Target | How to Measure |
|---|---|---|
| Issue Closure Rate | 1 issue/day (2 FTE) | GitHub project burn-down |
| Test Coverage | >80% | coverage report in CI |
| Schema Compliance | 100% | Contract tests pass |
| Reproducibility | 100% | Replay tests pass |
| E2E Latency | <5 min | Time request → result |
| Chemistry MSE | <0.5 | Solubility benchmark |
- Monitor GitHub Project board for flow (Backlog → Done)
- Unblock issues in "In Progress" stuck >2 days
- Track velocity (issues/week)
- Escalate blockers
- Weekly standup: Check "In Progress" column
- What's blocked?
- Do we need to pair?
- Are dependencies on track?
- Sprint planning (optional): Pick issues from "Ready" column
- Code review: Ensure DoD checklist before merge
- Refine: Move issues to "Ready" as dependencies clear
- Pick an issue from "Ready" column
- Move to "In Progress"
- Follow acceptance criteria exactly
- Write tests alongside code (TDD)
- Submit PR, move to "In Review"
- After merge, move to "Done"
- Pick next issue
- Phase 8 (Epic 8) is your involvement
- You'll review demos and provide feedback
- Target: ~week 10-12
- Purpose: Group related stories
- Usage: Filter board by epic to see related work
- P0: Critical path, blocks other work
- P1: Core features, high value
- P2: Support/validation features
- P3: Nice-to-have, demo/integration
- Low: 1-2 days (mainly Epic 1 schemas)
- Medium: 3-5 days (most modules)
- High: 1-2 weeks (complex state machines, integration)
- Identify blocker: Check "Depends on" in issue body
- Escalate: Comment on blocking issue + mention owner
- Workaround: Can you mock the dependency?
- Alternative: Is there a different issue to work on while unblocked?
- Check acceptance criteria: Are you adding new criteria?
- Extract: Create a new issue for the extra scope
- Link: Reference it in the current issue ("See also: #XYZ")
- Finish: Complete original scope first
- Checklist: All acceptance criteria done?
- Tests: >80% coverage? All pass?
- Schemas: Validate if applicable?
- Docs: README updated?
- Code review: Approved?
- Merge: Squash or rebase (keep history clean)
-
This week:
- Review this backlog overview
- Confirm priority tiers with team
- Assign Epic 1 lead (senior engineer)
-
Next week:
- Start Epic 1 (schemas) stories
- Finalize IntentSpec + ExecutionPlan schemas
- Begin design review for Epic 2 (control plane)
-
Ongoing:
- Daily standup: unblock issues
- Weekly review: measure velocity
- Monthly: adjust priorities based on feedback
Q: Can we start multiple epics in parallel?
A: Epics 3-7 can start after Epic 2 completes (~week 4). Not recommended to start multiple P0 epics in parallel.
Q: What if a story is larger than estimated?
A: Break it into subtasks (via GitHub Projects) or split into 2 issues.
Q: How do we handle bugs discovered during implementation?
A: Create a new bug: issue, link it to the story that caused it, prioritize in the board.
Q: Do we need a dedicated QA engineer?
A: No. Each engineer writes tests for their code (TDD). Validation engineer (2 FTE plan) handles acceptance.
- Project Summary:
../project/PROJECT_SUMMARY.md— executive overview - Review & Architecture:
../project/REVIEW.md— detailed architecture, gaps, recommendations - Implementation Roadmap:
../project/IMPLEMENTATION_ROADMAP.md— phased plan, resource plan - Getting Started:
../project/GETTING_STARTED.md— quick orientation - Detailed Backlog:
DETAILED_BACKLOG.md— full user stories (40+ items)
Last Updated: 2026-06-11
Created By: Claude Code
Status: Ready for implementation