Legacy applications are also often monolithic applications. Monolithic applications have two characteristics that make it desirable to modernize them: they are difficult to update, and they are difficult and expensive to scale.

Monolithic apps are difficult to update for architectural reasons. Because all of an application’s components ship together, it is difficult and costly to add features given the overhead of complexity and integration challenges.

They are challenging and costly to scale for similar reasons. If even one component of an app is facing load and performance challenges, it can become necessary to scale up the entire app only to serve the most-demanding single component. This approach comes with considerable wasted compute.

By modernizing an application to more of a microservices architecture, components are smaller, loosely coupled, and can be deployed and scaled independently of one another. While bringing its own set of challenges, this approach is where much of the core value in modernization can be found.

The following video explains more about microservices architectures:

The most important way to start any application modernization project is with an application assessment. Taking an inventory of what you have is almost always one of the most obvious ways to start just about any transformation like this.

Once you have a list, you can start plotting all of those applications against an x and y axis of ease/difficulty and potential increased value if modernized. You could also think of “potential” value as how critical the application is to customer experience and to your organization’s future.

The applications that fall into the top-right quadrant of this grid of high value and low effort will be the most-obvious, least-contentious candidates with which to begin an application modernization project.

The trickiest decisions will come down to the high-value apps that are difficult to move. For these, it also doesn’t need to be an all-or-nothing strategy on day one. There are approaches to application modernization, in these cases, that can reduce risk and cost while still moving your portfolio in the right direction.

There are a handful of well-known approaches to application modernization that focus on a combination of the platform, the application’s architecture, and exposing an application’s functionality via API.

From monolith to microservices. The most common pattern of application modernization involves refactoring and breaking down a monolithic application into a collection of small, loosely coupled microservices.

In the above example of microservices architectures, a retail application was broken down from a single, n-tier application to a collection of microservices of all of the individual services within the app, each with their database and data model.

One approach in this space is known as the “strangler pattern.” Instead of breaking down the monolith all at once, the strangler pattern is about taking the application apart bit by bit, pulling out the easiest and most valuable parts first, and as this approach progresses, eventually there’s nothing left of the monolith.

Cloud migration. Often part of refactoring to microservices, replatforming or rehosting applications is almost always part of the modernization process. While it’s possible to simply lift-and-shift applications without doing much of a substantial rewrite, more often, the value is found in restructuring the application to better take advantage of cloud models, often leveraging containers and Kubernetes. (Learn more about cloud migration.)

Expose functionality via APIs

Finally, another approach to modernization can involve leaving an application in place but securely exposing its functions or data via APIs. This approach, based more heavily on integration than migration, enables new, cloud native applications to simply take advantage of the capabilities of existing systems and data.

There’s a broad portfolio of technologies that can facilitate the modernization processes most organizations are going through.

Private cloud, hybrid cloud and multicloud

While public cloud is a critical part of any modernization strategy, private cloud, hybrid cloud and multicloud strategies are also critically important for security, latency and architectural reasons.

For any number of reasons, an organization might not be ready to go straight from the data center to public cloud, and the other cloud models can help solve for all the architectural and policy complexity associated with where certain workloads need to live based on their unique characteristics.

Containers and Kubernetes

Containers and Kubernetes have emerged not only as a challenger to virtual machines (VMs) as a form of all-purpose compute in the cloud, but a key enabler of hybrid cloud and application modernization strategies.

Containerization enables an application to be packaged in consistent, lightweight ways so that they can run consistently across desktop, cloud, or on-premises environments. This type of flexibility is a real benefit to organizations charting their path forward in the cloud.