Enterprises today have significant legacy software baggage built 10-15 years ago running in production. They are not secure owing to the lack of vendor support or patch upgrades but still play a crucial role in revenue generation and the day-to-day operation of the company. CIOs of these companies have to figure out a way to modernize their IT infrastructure while keeping their legacy systems. Modern technologies like Microservices and DevOps can give companies the leeway to run legacy systems while developing applications to attain feature parity or completely re-write the code until feature parity is attained.

Organizations modernize legacy systems using technologies like Microservices, APIs, Containers, and DevOps and often use frameworks to accelerate the process. The ability of these technologies to solve the organizational inefficiencies present in existing legacy and monolithic applications will be realized over a longer period.

When enterprises first started to digitalize, they built applications as monoliths in physical servers using the waterfall approach. Later on, they adopted the Agile process to build applications in a multi-tier architecture and virtual servers. The 2010s saw the emergence of DevOps, microservices architecture and containers for faster delivery and deployment. Time-to-market has become the key indicator for efficient IT infrastructure. The arrival of newer technologies has changed the objectives and challenges for companies. Currently, these are the most common objectives and challenges they face.

Objectives:

  • Have integrated CI/CD to reduce cycle times and make development team more productive
  • Get to auto scaling without having to worry about provisioning once deployed
  • Reduce wait time through self service
  • Move to API, Microservices & Containerization model

Let’s look at the common challenges and objectives from a CIO perspective

Challenges:

  • Maintaining systems integrity – Legacy systems that are not equipped to support modern business needs
  • Commercial off-the-shelf (COTS) software with no access to code base
  • Slow & costly development -Technological complexity of legacy systems combined with skill gap increases cost
  • Data security – Opening access to modern applications require security functionality since legacy systems are not designed for external access
  • The need to optimize IT for speed vs cost
  • Refactoring can be time consuming
  • Choosing between open source and lock in
  • Choosing between public and private cloud

A CIO’s Guide to Modernize Legacy Systems

The first thing in the list would be to assess the current scenario of the IT landscape in the company. Once there is clarity on this, you can choose from three approaches. Let’s look at some of them.

Migrate to Microservices and APIs

If it is a well architected legacy system, the first thing to do is to set the right goals. If the goal is to move towards a microservice, API approach, then containerize business critical applications and move to PaaS approach to run. This means components can be deployed independently. Upon reaching midpoint, check the possibility of refactoring the other applications to the end stage. This approach is suited for commercial off-the-shelf (COTS) or non-open source legacy software and smaller applications. Here, COTS lag because there is no access to the code base which means pieces of architecture must be visualized, layers defined ground up and then finally containerized.

Refactoring approach

Legacy systems are large and any modifications are not isolated and might have repercussions elsewhere. The best way to do in this case is to treat the legacy system as backend and re-invent from outside. If your business requires partner integration or mobility capability, you have to identify two integration points – one for functionality and one for data. Building a new platform on top using a container platform will mean not shutting down the legacy system and can be delivered in weeks. This way, you can continue to use the legacy system while getting innovative on the outside. Monolithic systems with environment lockdown in development and testing can adopt this approach. These applications would have typically been developed under the waterfall approach and being proprietary will lead to too much dependency. Automation in the development cycles will ease large releases with longer timelines. Refactoring will be time consuming, but the key is to isolate the pieces into separate containers without massive rewrite.

Completely Rewrite

This might be a tempting approach where the legacy system is totally replaced with a PaaS to run. All the legacy applications are shut down except a few that are rewrapped. The key here is to identify the stage where there is feature parity compared to the legacy system. The main challenge is to prioritize business use cases and features so that the code can be rewritten to achieve feature parity. The back end is shut down and new code is written in a microservices architecture and using APIs until parity is reached. Due to its complexity, this approach is easy to start but hard to finish. If the IT portfolio is too large and complex, it is best to start with a POC and then scale up.

As the saying goes, today’s software is tomorrow’s legacy. It’s important to modernize but it is essential to do so with the future in mind.

Are you ready to modernize your legacy applications? Learn how Aspire Systems can help you modernize.

Latest posts by Raghu Raghavan (see all)