Crafting and Executing Your Modernization Plan

With your Baseline established – a clear map of your legacy landscape and its dependencies – the OpenLegacy Hub Planner empowers you to move from understanding to action. The **Plans **section is where you define and execute your strategic modernization initiatives, transforming your legacy applications into modern, cloud-native services.

This article will guide you through creating and executing a Modernization Plan.

From Baseline to Plan: Your Strategic Blueprint

A Plan in the OpenLegacy Hub Planner is a detailed, actionable roadmap for modernizing specific components of your legacy estate. It builds directly upon the insights gathered in your Baseline, leveraging the identified dependencies to ensure a risk-free and phased transformation.

To begin, ensure you have a relevant Baseline selected. From the Planner interface, navigate to the "Plans" section in the left menu. Here, you can create a new Plan based on an existing Baseline.

Initiating Modernization Actions

The core of a Plan involves defining specific Modernization Actions. These actions represent the different strategies you can apply to transform your legacy applications.
The Planner supports various modernization approaches, including:

Refactor:
Re-architecting and rewriting parts of an application to leverage modern technologies and cloud-native patterns.

Rehost:
Moving an application from one environment to another without significant changes (e.g., from a mainframe to a cloud VM).

Augment: Enhancing existing legacy applications with new functionalities by creating microservices or APIs around them, without altering the core legacy code.

When you initiate an action, the Planner automatically helps you configure the transformation:

Selecting Apps and Technologies:
For instance, when you choose to "Refactor" an App, you'll specify the source legacy Apps, the target environment (e.g., AWS/Kubernetes), the desired technology (e.g., BluAge), and any target gateways.

Visualizing the Transformation:
As you define an action, the Planner visually updates the canvas. It will draw the related steps and show the intended state, such as:

• New Microservices/APIs: Represented in the target cloud environment (e.g., Kubernetes).
• New Proxy Programs/Bridges in the Backend: Indicating how the modernized services will interact with the remaining legacy components.
• Sunset Old Apps (Optional): While not immediately removed, the Planner can conceptually show how legacy components will eventually be phased out or become non-operational as their functionality is migrated.

This visual representation allows you to see the "before and after" of your modernization effort within the context of your broader architecture.

The Modernization Task List

Each modernization action you define automatically generates a comprehensive Modernization Tasks list.
This list serves as your guided workflow, breaking down the complex modernization process into manageable, executable steps.

The Task list typically appears on the right side of your Planner canvas, providing a clear overview of all pending and completed work.

Executing Your Modernization Tasks

The tasks in your Plan guide you through the implementation process. The OpenLegacy Hub streamlines several of these steps:

Create a Hub Module based on App Resources:
For tasks related to exposing legacy logic, the Planner facilitates the creation of OpenLegacy Hub Modules directly from the App Resources you defined in your Baseline. These Modules encapsulate the legacy business logic.

Create a Hub Modernization Project for the Bridge Microservice:
From these Modules, you can then generate the necessary bridge microservices or APIs using the Integration Designer, which will allow your new modern applications to interact with the remaining legacy systems.

External Tasks:
Some tasks might involve external processes, such as: Refactoring legacy Apps to specific platforms (e.g., Amazon BluAge): This might involve using third-party tools or manual refactoring efforts based on the Planner's guidance. Database Migrations: Moving data from legacy databases (e.g., DB2) to modern ones (e.g., PostgreSQL). The Planner helps you keep track of these diverse tasks within a single view.

As you execute each step, the Planner updates the visual representation on the canvas, showing the progress of your modernization, for instance, by marking newly created services or updated components.

Managing Task Status and Plan Completion
As you complete each task in your Modernization Plan, you'll update its status within the Planner. Tasks typically move through statuses like:

• Designed: The task has been defined as part of the plan.
• In Progress: Work has begun on the task.
• Developed: The code or solution for the task has been developed.
• Tested: The task has been tested.
• Completed: The task is fully executed and verified.

Changing the task status provides real-time progress tracking for your entire modernization initiative.

On the completion of all tasks, your Modernization Plan is successfully completed. This signifies that the defined scope of modernization has been achieved, and the new, modernized components are in place, often with the original legacy components either phased out or operating in coexistence.

Your Path to Accelerated Modernization
The OpenLegacy Hub Planner, through its robust Baseline and Plan functionalities, provides an unparalleled framework for tackling even the most complex legacy modernization challenges. By breaking down the process into clear, manageable steps, it de-risks the transformation, accelerates time-to-value, and ensures that your critical business logic is successfully transitioned to a modern, agile architecture.