What a Modernization Plan Is

A Modernization Plan is a structured set of executable tasks that implement a specific modernization action on selected applications, integrations, or data assets within a Baseline.

A plan represents the operational path from:

The current architecture state (Baseline)
To a target modernization outcome, such as refactoring, rehosting, augmentation, or data replication

A plan consists of:

A single Plan Action (Refactor, Rehost, Reimagine, Augment, or Capture)
A set of generated and manual tasks
An execution flow that defines task order, dependencies, and governance controls

Plans are always created intentionally. They are never executed automatically. Each plan must be reviewed and approved before execution.

When to Create a Plan

Create a plan when:

A valid Baseline exists with defined environments, applications, and dependencies
A specific modernization objective has been selected (for example: rehost an application, expose APIs, or replicate data)
You want to execute modernization in a controlled, traceable, and phased manner

Plan Actions

Each plan is based on a single Plan Action, selected from the Plan Action menu:

Action	Purpose
Refactor	Restructure existing application logic to improve modularity and maintainability without changing external behavior.
Rehost	Move applications to a new runtime or infrastructure with minimal or no code changes.
Reimagine	Redesign or rewrite the application using a new architecture or implementation.
Augment	Extend existing systems with new APIs, integrations, or digital capabilities without replacing the core system.
Capture	Replicate and synchronize data changes using Change Data Capture (CDC).

Each action determines:

The type of tasks generated
The execution flow
The role of the OpenLegacy Hub during execution

Steps to Craft a Modernization Plan

1. Select Plan Action

Choose one of the available Plan Actions:

Refactor
Rehost
Reimagine
Augment
Capture

The selected action defines the technical scope and task model of the plan.

2. Generate Plan from the Baseline

Planner analyzes the selected applications and their dependencies, including:

Program calls
Database and file access
Integrations and messaging
Batch and scheduling relationships

Based on this analysis, Planner generates a draft execution plan aligned with the selected Plan Action.

3. Review and Adjust the Plan

The generated plan is presented as a draft. You can:

Inspect affected applications and dependencies
Adjust task scope
Change execution order
Add manual validation or approval steps
Remove or split tasks as needed

4. Approve the Plan

Once the plan reflects the correct technical scope and execution flow, it must be explicitly approved before execution.

5. Export Plan to the Hub

After approval, the plan is exported to the OpenLegacy Hub, where:

Tasks are materialized
Execution order is enforced
Environments, credentials, and permissions are applied

6. Execute Tasks via the Hub

Tasks are executed according to the plan’s execution flow. The Hub manages:

Deployment
Orchestration
Runtime monitoring
Logging and audit trails

7. Monitor and Iterate

Execution progress and outcomes are monitored in the Hub. You can:

Validate task results
Investigate failures
Create additional plans for subsequent modernization phases

Plan Structure and Key Concepts

Concept	Description
Plan Action	The selected modernization operation (Refactor, Rehost, Reimagine, Augment, Capture).
Plan	A structured, approved set of modernization tasks derived from a Baseline.
Task	A discrete executable unit such as service generation, deployment, or CDC job creation.
Execution Flow	The ordered sequence of tasks with enforced dependencies.
Approval	Manual authorization step required before execution.
Execution via Hub	Runtime orchestration, monitoring, and audit managed by OpenLegacy Hub.

Best Practices for Planning and Execution

Ensure the Baseline is complete and accurate. Dependency analysis depends on the quality of the Baseline.
Select the correct Plan Action. Each action produces a different task model and execution behavior.
Review all generated tasks before approval. Validate technical scope and execution order.
Use phased execution for large systems. Execute in controlled increments.
Rely on Hub governance. Use access control, audit logs, and execution permissions.
Validate outcomes after each phase. Use monitoring and system verification before proceeding.

When to Update or Create a New Plan

Create a new plan when:

The Baseline changes
A different Plan Action is required
A modernization phase is completed
Additional application or data scope is introduced
Compliance or audit requirements require a revised execution path

Each plan should reference:

A specific Baseline version
A single Plan Action
A defined execution scope

Summary

With OpenLegacy Planner you can:

Convert Baselines into executable modernization plans
Apply structured modernization actions (Refactor, Rehost, Reimagine, Augment, Capture)
Review and approve all automation before execution
Execute tasks through governed orchestration in the OpenLegacy Hub
Maintain full auditability and traceability across all modernization phases