This content is part of the Essential Guide: Guide to app portfolio management and legacy modernization
Evaluate Weigh the pros and cons of technologies, products and projects you are considering.

Legacy modernization: Why you should take an Agile-DevOps approach

The Agile-DevOps approach to legacy modernization transforms slow-performing old apps into resource-efficient apps without operational issues.

Instead of performing application upgrades, taking an Agile-DevOps approach to legacy modernization can ensure...

resources are optimally consumed. The Agile-DevOps method is beneficial because it makes sure a modernized application runs efficiently and as expected.

Businessman's hand selecting a rectangle

There are three main Agile-DevOps approaches to legacy modernization that can reveal operational issues of a modernized application. Each method can also expose what expectations have not been realized even when operational issues aren't present.

Re-hosting a legacy system to a new platform

Re-hosting a legacy system on a new platform without major changes to the system seems to be the easiest option. This approach includes legacy systems that work well in-house and are re-hosted to run in the cloud without issues.

The complexity of dependencies is likely to increase with frequent upgrades and re-patches.

This method is less desirable when operational issues reveal that running the re-hosted legacy system doesn't scale or consume resources more efficiently than on the old platform. Running on a new platform may require major changes to the legacy code on specific resource uses.

Migrating legacy systems to a relational database system

While moving an old application to a relational database system seems like a good legacy modernization technique, the Agile-DevOps approach may reveal operational issues querying the relational database. Such problems include slow query responses, network latency, overloading the server hosting the database, excessive resource consumption and improper partitioning of data.

To minimize operational issues and achieve query optimization, start the Agile-DevOps approach with the incremental iterations of database optimization. This encompasses table normalization and designing indexes to support efficient queries.

Decomposing legacy systems into service-related components

If you're going the legacy-system-decomposition route, a business process improvement plan should be in place before starting the Agile-DevOps approach. The plan helps determine which legacy-system service-related components should be extracted for incorporation into a modernized application, such as Software as a Service.

More on legacy modernization

Five signs it's time for app modernization

What to consider before legacy migration

Top benefits of app modernization

To make it easier to untangle component dependencies, start with the incremental iterations of decomposition. The complexity of dependencies is likely to increase with frequent upgrades and re-patches.

Once the dependencies are successfully untwisted, the service-related components can be accepted, rejected or combined. The accepted components can be put in a repository for consideration in other legacy modernization projects.

Service components can be rejected if they aren't used anymore, are outdated or result in slow responses. Accepted service components do not always mean that dependencies among these components are acceptable.

Accepted dependencies may require restructuring of accepted service components. Use the Agile-DevOps approach for incremental iterations of component reconstruction. During the iterations, combine dependencies to result in fewer service components. The DevOps iterations of operations can reveal operational issues of an application with accepted service components.

Follow us on Twitter at @SearchSOA and like us on Facebook.

Dig Deeper on Application modernization

Join the conversation


Send me notifications when other members comment.

Please create a username to comment.

Have you taken the Agile-DevOps approach toward legacy modernization?
We're definitely focusing on more deployments, especially in our staging environment (which for our organization really is our production environment). In that frame, we deploy daily and sometime two or three times a day if we are really cranking out stories simultaneously. The process allows us to incrementally update key areas, and also allows us to tackle larger areas that are perhaps no longer supported.
Thanks for sharing some of the benefits you've found taking an Agile-DevOps approach with your work, Michael.