Persistent’s 8-Step Plan for a Successful Product Modernization Journey

Back to table of contents

A Proven Approach to Reinventing Your Software Products—and Your Software Development Methodology

“Strangling the Monolith”: The Starting Point of the Modernization Journey

6 minute read

Back to table of contents

Containerization is the first half step, next being iterative refactoring through Strangler pattern

Business microservices form the heart of system, discoverable in the service registry and connected via service mesh

Business microservices to be flanked by others microservices, including BFF

Next steps

Re-imagine software products

Leverage our expertise in next-gen MACH software architectures to modernize your software products quickly.

Learn More

Rejuvenate mature products

Focus on improving revenue, efficiency and customer delight with our intelligent sustenance engineering framework.

Learn More

Re-group with our experts

Schedule a discussion with our modernization and sustenance experts who can help you chart a path forward.

Next steps

Re-imagine software products

Leverage our expertise in next-gen MACH software architectures to modernize your software products quickly.

Learn More

Rejuvenate mature products

Focus on improving revenue, efficiency and customer delight with our intelligent sustenance engineering framework.

Learn More

Re-group with our experts

Schedule a discussion with our modernization and sustenance experts who can help you chart a path forward.

Of the eight components in the modernization journey, six aspects are related to software development and two are related to the DevSecOps for the software process.

It’s important to note that there is no requirement that these steps be done in numerical order; indeed, organizations have successfully accomplished them in alternative patterns.

In most cases, however, the logical starting order is as follows:

1\ Containerization is the first half-step, followed by iterative refactoring through the strangler pattern.

The first step in the journey—really a half-step—is to begin by containerizing the monolith. As the entire monolith migrates to the cloud, it’s essential to understand the cloud capabilities required to scale the software in the following steps. As you begin to iteratively strangle the application, begin looking for hairline cracks to develop. Since we’ve taken a small piece of the application out of the monolith and created a microservice in its place, one or more functions may not work properly. Identify and fix the issues, and then repeat the process.

1. Containerization is the first half-step, followed by iterative refactoring through the strangler pattern.

2. Business microservices form the heart of the system, discoverable in the service registry and connected via the service mesh.

3. Business microservices to be flanked by other microservices, including Backends for Frontends (BFF).

1. Containerization is the first half-step, followed by iterative refactoring through the strangler pattern.

When you begin strangling the monolith, you will start creating business microservices before you create any other kind of microservice. Each of these services needs to connect with the others in a service mesh. It’s also important to establish a registry at this point, where you can discover what other microservices exist. As each microservice is created, it needs to be done using event-driven architecture—because microservices must not be coupled with each other—and it must be cloud-native.

2. Business microservices form the heart of the system, discoverable in the service registry and connected via the service mesh.

3. Business microservices to be flanked by other microservices, including Backends for Frontends (BFF).

1. Containerization is the first half-step, followed by iterative refactoring through the strangler pattern.

The business microservice that is considered the key microservice needs to be flanked or chaperoned by other microservices. One common example is Backend for Frontend, a.k.a., BFF. As microservices manage various business capabilities, there are different types of frontend capabilities that need to be addressed: for example, a mobile application, single-page application, or web application. Creating multiple backends for the frontends enables a loose coupling between the frontend and the business microservice. This is particularly important when you are scaling up multiple client-related microservices, or when you have multiple different clients with many people logging in. This also comes into play for interaction with legacy systems, including bespoke, ERP, or SaaS systems. For example, if an organization is using Salesforce as SaaS, it is a best practice to create multiple adopter microservices. That way, in the event a microservice goes down, the entire system won’t get stuck. This situation can be resolved by using a circuit breaker pattern: If a process is taking too much time, the circuit breaker will break the circuit and shift to one of the flanking microservices around the business microservice.

3. Business microservices to be flanked by other microservices, including Backends for Frontends (BFF).

2. Business microservices form the heart of the system, discoverable in the service registry and connected via the service mesh.

Orient all the microservices around event processing by setting up event-driven architecture

Need to build a Polyglot persistence through scalable store

Ensure that native / SPA with micro frontend uses intelligent frontend components

Cloud Native DevSecOps brings together everything that is needed to deliver microservices based product using…

Orient all the microservices around event processing by setting up event-driven architecture

4. Orient all the microservices around event processing by setting up event-driven architecture.

5. Build a polyglot persistence through a scalable store.

6. Ensure that native/SPA with a micro-frontend uses intelligent frontend components.

7. Cloud native DevSecOps brings together everything that is needed to deliver a microservices-based product.

8. Incorporating a CI/CD pipeline of containers into which each of the microservices would be deployed.

4. Orient all the microservices around event processing by setting up event-driven architecture.

5. Build a polyglot persistence through a scalable store.

6. Ensure that native/SPA with a micro-frontend uses intelligent frontend components.

7. Cloud native DevSecOps brings together everything that is needed to deliver a microservices-based product.

8. Incorporating a CI/CD pipeline of containers into which each of the microservices would be deployed.

4. Orient all the microservices around event processing by setting up event-driven architecture.

5. Build a polyglot persistence through a scalable store.

6. Ensure that native/SPA with a micro-frontend uses intelligent frontend components.

7. Cloud native DevSecOps brings together everything that is needed to deliver a microservices-based product.

8. Incorporating a CI/CD pipeline of containers into which each of the microservices would be deployed.

1. Containerization is the first half-step, followed by iterative refactoring through the strangler pattern.

2. Business microservices form the heart of the system, discoverable in the service registry and connected via the service mesh.

With multiple microservices flanking around the business microservice, they need to be able to talk to each other through what is referred to as an event backbone, an event pipeline, or a queue. No matter the name, the key is to have communication routed through an event-driven architecture.

3. Business microservices to be flanked by other microservices, including Backends for Frontends (BFF).

4. Orient all the microservices around event processing by setting up event-driven architecture.

5. Build a polyglot persistence through a scalable store.

6. Ensure that native/SPA with a micro-frontend uses intelligent frontend components.

7. Cloud native DevSecOps brings together everything that is needed to deliver a microservices-based product.

8. Incorporating a CI/CD pipeline of containers into which each of the microservices would be deployed.

1. Containerization is the first half-step, followed by iterative refactoring through he strangler pattern.

2. Business microservices form the heart of the system, discoverable in the service registry and connected via the service mesh.

Some microservices are built for authenticating the user. Others are related to picking out some information and sharing it with the customer. Some are tasked with comparing two different customers and deriving some information from that comparison. But if everything resides in the same common database and two microservices attempt to make a simultaneous update, there will be a lock. To overcome this, each microservice requires a polyglot and multiple kinds of persistence mechanisms and databases. This approach enables the microservices to work independently and elegantly, improving performance by huge magnitude. There are numerous ways to network the databases in a decentralized fashion, including a cable store, a key value or a document store.

3. Business microservices to be flanked by other microservices, including Backends for Frontends (BFF).

4. Orient all the microservices around event processing by setting up event-driven architecture.

5. Build a polyglot persistence through a scalable store.

6. Ensure that native/SPA with a micro-frontend uses intelligent frontend components.

7. Cloud native DevSecOps brings together everything that is needed to eliver a microservices based product.

8. Incorporating a CI/CD pipeline of containers into which each of the microservices would be deployed.

1. Containerization is the first half-step, followed by iterative refactoring through the strangler pattern.

2. Business microservices form the heart of the system, discoverable in the service registry and connected via the service mesh.

3. Business microservices to be flanked by other microservices, including Backends for Frontends (BFF).

4. Orient all the microservices around event processing by setting up event-driven architecture.

This is the final aspect of software development within the 8-fold path for building (or rebuilding) the software product. Designing the frontend may include a browser single application or the native application, mobile or web-based, which can either talk to the adopter or the business microservice and make sure that information is provided in an intelligent fashion to the end user.

5. Build a polyglot persistence through a scalable store.

6. Ensure that native/SPA with a micro-frontend uses intelligent frontend components.

7. Cloud native DevSecOps brings together everything that is needed to deliver a microservices-based product.

8. Incorporating a CI/CD pipeline of containers into which each of the microservices would be deployed.

1. Containerization is the first half-step, followed by iterative refactoring through the strangler pattern.

2. Business microservices form the heart of the system, discoverable in the service registry and connected via the service mesh.

3. Business microservices to be flanked by other microservices, including Backends for Frontends (BFF).

4. Orient all the microservices around event processing by setting up event-driven architecture.

Building a product starts with the end in mind, including having a new way of managing and controlling the build and decline of the product over time. This step includes two considerations: / First, no matter which cloud has been selected to implement your microservices, each cloud partner must provide their own native DevSecOps with the aspects that need to be accommodated. Some of the factors are related to auto-scaling. For example, Amazon Web Services (AWS) provides auto-scaling in a specific fashion, while Azure handles it differently. / Each of them also provides certain query engines, which can be used to generate logs and determine whether functions are happening properly or not. And at the heart of all of it is the continuous integration/continuous deployment (CI/CD) pipeline.

5. Build a polyglot persistence through a scalable store.

6. Ensure that native/SPA with a micro-frontend uses intelligent frontend components.

7. Cloud native DevSecOps brings together everything that is needed to deliver a microservices-based product.

8. Incorporating a CI/CD pipeline of containers into which each of the microservices would be deployed.

1. Containerization is the first half-step, followed by iterative refactoring through the strangler pattern.

2. Business microservices form the heart of the system, discoverable in the service registry and connected via the service mesh.

3. Business microservices to be flanked by other microservices, including Backends for Frontends (BFF).

4. Orient all the microservices around event processing by setting up event-driven architecture.

The CI/CD pipeline should be available from any cloud native DevSecOps. Different kinds of deployment strategies can be utilized within the pipeline, so if one deployment does not occur properly, another is there to back it up. For example, canary testing is a useful approach for testing a new feature with a specific set of users before pushing it out to all users. Feature toggle is similar, but instead of testing one set of features, it delivers two different sets of features to two different sets of users. Each microservice goes through its own lifecycle once it is placed in the CI/CD pipeline. One challenge with the public cloud is that each cloud provider has its vulnerability definitions, which is a problem if the docker build or the code itself is has any vulnerability. That’s why it’s important to use a vulnerability scanner: As the docker build goes through the birthing pool, it will count certain image repositories, which are finally approved through that entire process. With the vulnerabilities addressed, the hardening is done, and you are ready for deployment. The code goes into one of multiple public image registries, and from there, to a high-availability container in the Public Register and orchestration system.

5. Build a polyglot persistence through a scalable store.

6. Ensure that native/SPA with a micro-frontend uses intelligent frontend components.

7. Cloud native DevSecOps brings together everything that is needed to deliver a microservices-based product.

8. Incorporating a CI/CD pipeline of containers into which each of the microservices would be deployed.

Of the eight components in the modernization journey, six aspects are related to software development and two are related to the DevSecOps for the software process.

In most cases, however, the logical starting order is as follows: