Cloud Modernization Patterns Module 1 · Size It Up

The Phased Roadmap

Updated

Intermediate

What you'll learn

~15 min
  • Sequence modernization phases by a defensible priority rule, not by excitement
  • Score ROI per phase honestly -- including the phases with low returns
  • Break a phase into atomic task packs an AI CLI (or a teammate) can execute independently

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:

PhaseWorkWhy this position
1Patch/upgrade every known-vulnerable dependency in AssetTrack; secrets out of config filesSecurity debt is unbudgeted risk compounding daily
2Stand up the new FieldDesk MVP for one departmentVisible win in weeks; validates the platform choices
3Port AssetTrack’s core services to modern .NET; characterization tests firstEvery later phase depends on a portable runtime
4Decompose the batch jobs; untangle business rules from stored proceduresThe slow, compounding payoff
5UI polish, dashboard consolidationReal value, honestly labeled last

Per-phase ROI honesty

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

PhaseCost (relative)ReturnHonest score
Security remediationLowRisk eliminationCritical
FieldDesk MVPMediumDirect user valueHigh
.NET port + testsHighUnlocks everything afterHigh (enabling)
Batch decompositionHighOps reductionMedium
UI polishMediumSatisfactionLow

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.

💬The roadmap is a negotiation artifact

Budgets move, priorities shift, a storm season eats a quarter. A phase-scored roadmap survives this because it was built to be cut from the bottom. A monolithic 18-month plan survives nothing.

Atomic task packs

Within a phase, work breaks into task packs — units scoped so tightly that any executor (a teammate, or your workspace agent in a build session) can pick one up cold. Switch your workspace agent to Plan mode on your roadmap and repository, and ask it to decompose Phase 3:

Break Phase 3 (porting AssetTrack's core services to .NET 10) into atomic task packs with declared file scopes, tests, and dependencies. Mark which tasks can run in parallel and which are MVP versus Phase-2 scope.

Check that the plan or draft covers:

  • Explicit scope (what changes and what is out of scope) and exact file paths each task may touch
  • Any database schema deltas (or "none") and the specific verification tests that prove the task done
  • Task dependency numbers, a dependency graph, and a Parallel-safe: yes/no flag based on non-overlapping file scope
  • An MVP versus Phase-2 split inside each task so descoping is a line edit

If two tasks marked parallel-safe touch the same file path, follow up with: Serialize any tasks that share file paths or split the shared file into a prerequisite task.

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.

KNOWLEDGE CHECK

Why should the roadmap's per-phase ROI table include phases scored 'low'?

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.

Search lessons