Application modernization is the process of migrating an incumbent or legacy software application to modern development patterns, paradigms and platforms with the explicit purpose of improving business value. This implies improving the software architecture, application infrastructure, development techniques and business strategy using a cloud native approach.
Modernizing software architecture is often described as splitting a monolithic codebase but can imply any improvements to the software itself, such as decoupling of components or addressing tech debt in the codebase. Other examples might be finding new design patters that allow for scale, addressing resiliency within an application or improving observability through logs and tracing.
We often think of application modernization in the context of cloud, and when planning a migration to cloud or modernizing an application already in the cloud, we look at what services and platforms are beneficial to the effort. Utilizing a service such as Amazon S3 for serving documents instead of a network share or utilizing ElasticSearch instead of the database for search are examples of infrastructure improvements. Containerization and other serverless platforms are also considered.
Development techniques also need to be addressed in the context of modernization. Developers should focus on the parts of the application that deliver value to customers and provide competitive advantage. If developers are focused on maintenance, long manual deployments, bugs, and log investigation, they are unable to deliver value quickly. When working with modern distributed cloud applications, teams need to follow strong DevOps practices in order to be successful. CI/CD, unit testing, diagnostics and alerting are all areas that development teams can focus on modernizing.
In this context, legacy software refers to an incumbent application or system that blocks or slows an organization’s ability to accomplish its business goals. These systems still provide value and are great candidates for modernization.
Legacy can imply many things, but some common characteristics of legacy apps are:
- Applications that run older libraries, outdated frameworks, or development platforms or operating systems that are no longer supported.
- Architectural issues – monolithic or tightly coupled systems can lead to difficulties in deployment, long release cycles and high defect rates.
- Large amounts of technical debt, dead or unused code, teams who no longer understand how older parts of the application work, etc.
- Security issues caused by technical debt, outdated security paradigms, unpatched operating systems, and improper secret management.
- Lack instrumentation with no way to observe the application.
- Maintain session state on the client (require sticky sessions, etc.).
- Manually deployed or must be deployed in specific ways due to tight coupling.
Pillars of Modernization
When approaching a modernization project, we specifically look to ensure the following:
The modernization initiative should follow a distributed computing approach, meaning it should take advantage of concepts such as elasticity, resiliency, and containerization. Converting applications to adhere to the principals of the “12-factor app” in order to take advantage of containerization is a prime example.
The application must be built, tested and deployed using modern CI/CD processes. Older source control paradigms such as RCS or SVN should be replaced with distributed version control systems (git). Infrastructure as code should be included as part of the CI/CD system.
Holistically integrate logs, metrics, and events enabling “the power to ask new questions of your system, without having to ship new code or gather new data in order to ask those new questions” (Charity Majors https://www.honeycomb.io/blog/observability-a-manifesto). Observability is key to understanding performance, error rates, and communication patterns and enables the ability to measure your system and establish baselines.
Application teams should be aligned along business function, not technology, meaning multi-disciplinary teams that can handle operations (DevOps), database, testing (QA) and development. A culture of ownership is important in a cloud-native application.
Application Modernization is not:
- Just containerization – To take full advantage of containerization, applications must be properly architected (12-factor), instrumented for observability and deployed using CI/CD.
- Just technical solutions adapting the latest framework or technology – The technology might be “modern” in a sense but doesn’t necessarily address cultural or legacy architectural issues.
- Just addressing TCO – Addressing cost savings without addressing legacy issues does not constitute modernization.
- Just running a workload in the cloud
- Just changing database platforms – Licensing issues or the desire to move to open source clustered cloud databases does not equate to modernization.
Application modernization includes, among others, combinations of:
- Moving a SaaS application from a single to multi-tenant environment.
- Breaking up a monolithic application into microservices.
- Applying event driven architecture to decouple and separate concerns.
- Utilizing cloud services such as S3 to replace in-house solutions.
- Refactoring to use NoSQL technologies such as MongoDB, ElasticSearch, or Redis.
- Containerization and utilization of PaaS technologies such as Kubernetes or Nomad.
- Utilization of Serverless (FaaS) technologies such as AWS Lambda, Azure Functions, OpenFaas, or Kubeless.
- Creating strong API abstractions like REST or gRPC and utilizing API Gateways.
- Transitioning to client-side rendering frameworks (React, Vue.js, etc.) and serverless edge deployment of UI assets, removing the webserver.
- Moving long running synchronous tasks to asynchronous batch processes.
- Utilizing saga patterns or business process workflows.
If you’re ready to start considering application modernization in your organization, contact us for guidance on how to get started.
-James Connell, Sr Cloud Consultant