The Phased Roadmap

From decision to sequence

The steering committee accepted the analysis: FieldDesk gets rebuilt, AssetTrack gets decomposed, the reporting share gets a real data platform. Now everything is possible and nothing is sequenced. A roadmap is where you decide order — and order has rules.

The priority rule

Phases are ordered by a rule you can defend, and it looks like this:

1. Security exposure     - non-negotiable, always first
2. Quick wins            - visible improvements that buy political capital
3. Foundations           - work that later phases stand on
4. Complexity reduction  - the long-haul refactoring
5. Nice-to-have          - explicitly labeled as such

For Meridian, that ordering produces:

Per-phase ROI honesty

Here is a discipline most roadmaps skip: score the return of every phase separately, and let some scores be low.

The low score on the last row is not a weakness of the roadmap — it is what makes the total believable. A roadmap where every phase claims “high ROI” is a sales document. When leadership asks “what can we cut if the budget shrinks?”, the honest table answers instantly: cut from the bottom.

Atomic task packs

Within a phase, work breaks into task packs — units scoped so tightly that any executor (a teammate, or your AI CLI in a long session) can pick one up cold. Prompt first:

Break Phase 3 (port AssetTrack's core services to .NET 10) into atomic tasks.
For each task produce:
- Scope: exactly what changes, and what is explicitly out of scope
- Files: the paths this task may touch
- Schema deltas: any database changes, or "none"
- Tests: what proves this task done
- Dependencies: which task numbers must land first
- Parallel-safe: yes/no -- can this run alongside its siblings?

Also produce a dependency graph of the tasks, and mark which tasks are
MVP versus Phase-2 scope.

The properties that make a pack “atomic”:

• Declared file scope — two parallel tasks that touch the same file are not parallel; the pack format surfaces that before the collision
• A guardrails-first ordering — the task that sets up lint rules, test scaffolding, and CI gates lands before the tasks it protects
• MVP vs Phase-2 split inside every task — so descoping is a line edit, not a renegotiation
• One global definition of done — for Meridian: types clean, tests green, no route without an authorization check

This format is precisely what makes AI execution safe at scale: each pack is a self-contained brief with its own verification. You will see the same shape again in Lesson 4.3, where the promotion checklist gets the same treatment.

Key takeaway

Sequence by rule (security → quick wins → foundations → complexity → polish), score every phase’s return honestly, and decompose phases into atomic task packs with declared scope, tests, and dependencies. That structure is what lets both your team and your AI CLI execute in parallel without collisions — and what lets the roadmap bend instead of break.