Modernize: Five Pathways To Level Up Your Apps And Infrastructure

The cloud-native paradigm for application development and delivery lights a pathway for organizations to modernize their existing applications and underlying infrastructure — all to achieve benefits ranging from faster time to market, ease of maintenance, granular scalability, and cost-effectiveness.

Is your business ready to modernize? Here are five considerations that will help you realize a pathway to progress.

1Make An App Inventory And Separate It Into Buckets

Before embarking on a modernization initiative, classify your existing applications first. This process helps determine which apps are the low-hanging fruit and those that will take longer to modernize (or should just be left alone). A simple example is Windows versus Linux. Cloud-native technology stacks historically have favored Linux. Technology vendors like Docker, however, have made contributions to running Windows apps on containers, but these are still not as mature as Linux. Having a clear understanding of how many Windows apps are being run today can help you understand which technologies would make more sense to utilize.

What about single-purpose applications? Modernizing is easier if an application is already well decomposed into distinct responsibilities and components. If it’s monolithic, that usually means combining a bunch of components into a virtual machine, with tight dependencies between each other. Those applications will tend to be more difficult to modernize.

Another application classification is stateful versus stateless. Most modern application frameworks are optimized for stateless applications, which makes it easy to scale up and down a particular component of an application. Stateful applications like databases, message queues and key-value stores tend to take longer to modernize.

2Determine How Your App Will Be Delivered

Considering the delivery vehicle(s) for your applications will help determine if you should be using virtual machines, containers or serverless functions. Modern application design patterns are actually based on the principles of scalability, statelessness and high availability — and can still be delivered by using a virtual machine. There’s no rule for having to use containers or functions. For example, Netflix runs their services in a highly scalable and available form, using many of the design principles of modern applications, and the company has been using virtual machines for many years.

Sometimes the most suitable delivery vehicle for an application is based on preferences. A developer team may be more comfortable with one vehicle type versus another, which affects the choices in technologies and frameworks used to run those workloads.

Another thing to consider is deployment targets. Is there a move to the public cloud coming, or is there a need to keep apps hosted on premises? Perhaps there is a combination of public cloud and private data centers? Ensure that whatever technology stack is chosen will be predominantly open-source — because there will be better chances for interoperability or portability across clouds or environments and you can avoid lock-in.

3Decompose Apps Early And Often

Decomposing your applications into services is really important. To “decompose” your apps, try to draw lines around the pieces of your applications that serve different functions, then see (for each of these service tiers) whether they’re stateless and whether they can be scaled horizontally. For example, a database tier can be left alone and continue to use a specialized external database with a dedicated team running on local hardware. But if an application has a tier that is stateless and can be scaled horizontally, that’s a good candidate to modernize, repackage and target for a container or a function type of platform.

When packaging scalable service tiers, decide if they will run in a container or run in a function. Regardless of what you choose, you can always rely on the standard for creating modern apps, which is called Twelve-Factor. These 12 recommendations for how to build and configure a modern application will cover everything from the codebase to administrative processes.

Applications that are already well organized into recognizable tiers are good candidates to modernize because their decomposition has already been architected. For example, three-tier apps composed of a web frontend, an application service and a database tend to be easier to modernize.

4Kubernetes to the Rescue

Once an app is architected, Kubernetes, an open-source software platform, will help with the operational aspects of running those applications. One example is automatic healing. If there is a service that can support and number replicas of an application, Kubernetes can automatically scale up and down based on demand. If a workload or a replica dies, Kubernetes will automatically replace it. Kubernetes also helps with service discovery by automatically configuring its own DNS server to register the application name in its registry, so that other applications can discover the existence of the new app and get an IP address back to be able to connect to the app.

Making investments into containerizing an application helps with modernizing apps and future-proofing. Kubernetes is the de facto standard for container orchestration, and it provides portability and a more robust operational practice. While Kubernetes is great, it is notoriously difficult to deploy and operate on an enterprise scale — particularly when running on mixed infrastructure. Consult different solutions designed to help you take advantage of Kubernetes in production to see which one is best for your needs.

5Serverless Accelerates Modernization

Kubernetes has dozens, if not hundreds, of complex abstractions and concepts that need to be learned right out of the box. But, if people have a good grasp of what an application needs and follow many of the practices previously discussed, embracing a serverless framework is the next step.

If serverless is a good fit for an application, it can provide a boost by significantly simplifying the process of app modernization. A serverless framework should run an application in the most optimal and scalable way possible.


By modernizing your applications and infrastructure, your organization can develop faster, operate more easily and scale independently. Modernizing requires a lot of consideration, but many of these functions will help your team achieve great granularity in your processes and help your applications better respond to daily events. How will your business take the leap?

This article originally appeared on Forbes Tech Council


You may also enjoy

Kubernetes FinOps: Right-sizing Kubernetes workloads

By Joe Thompson

The argument for AWS Spot Instances

By Chris Jones

The browser you are using is outdated. For the best experience please download or update your browser to one of the following:

State of Kubernetes FinOps Survey – Win 13 prizes including a MacBook Air.Start Now