Application Modernization

Application Modernization

Constraints of monolithic code base and tightly coupled architecture

Legacy software applications often have a monolithic code base with tightly-coupled architecture which are relatively easy to develop, test, and deploy. But, as they become large and complex, numerous drawbacks of monolithic applications become amply evident, such as:

Difficulty in maintaining code base: As the application becomes complex with a large monolithic code base, it becomes very difficult to understand, maintain and modify, especially for newer team members. This results in a natural downward spiral in terms of code quality. With a monolithic code base, it also becomes very difficult to scale the development organization.

Obstacles to incremental changes and frequent deployment: In the absence of modularity, even small changes will need a complete redeployment of the application. This obviously increases the risks associated with redeployment, discourages frequent updates, and either accumulates technology debt or delays important changes to the application. Most importantly, this prevents continuous deployment, which is one of the core application needs in the current business context.

Inability to scale: For applications with a monolithic architecture, scaling is possible only through running multiple instances of the application, which is a very inefficient way to handle transaction and data volumes. The tightly coupled architecture of legacy applications, doesn’t allow for separation of resource requirements (such as CPU, memory etc.), making it impossible to scale components independently.

Barriers to adoption of newer technology: One of the biggest constraints of applications with monolithic architecture, is that they are very often locked-into specific technology choices for a long time. Lack of modularity makes it even more difficult to adopt newer technologies (programming languages and frameworks), resulting in increasing obsolescence of these applications.

Mesh App and Services Architecture (MASA)

A popular strategy to overcome the above cited challenges is by adopting a MASA pattern, which calls for a re-design of the legacy application as a set of loosely-coupled, collaborating services with the following concepts:

  • Loosely coupled and multi-tiered
  • Service-oriented and API-based architecture
  • Extensible data model with security
  • Support for multi-tenancy
  • Flexible and modular components
  • Design for performance and scaling

Mesh App and Services Architecture (MASA)

Advantages of MASA

Modernizing legacy applications with MASA offers the following benefits:

  • easier to maintain, change, and upgrade
  • allows for continuous and independent deployment of services
  • enhanced scalability
  • avoids long-term technology lock-in
  • makes it easier to adopt newer technologies
  • provides flexibility to package services into multiple applications
  • enables scaling of development organization around, multiple component or service teams

Decomposition of application into services

One of the critical challenges in adopting MASA, is in decomposing the legacy, monolithic application into a set of services. While, there is no one size-fit all approach, some popular and tested strategies for decomposition into services are:

  • by business capabilities
  • by application’s business sub-domains
  • by use cases

It is ideal to define a service in such a way that it has a small set of responsibilities, with its own database, and which can be developed by a small 2-pizza team.

To learn more about our services, get in touch