How Creditas Solved Monolith Problems with Application Modernization

At Creditas, a leading fintech company with almost 4000 employees, we faced a common problem in the software industry: monoliths. Our monolith called Core was shared with multiple contexts and products, consumed by multiple business units and customers with more than 60K commits. However, its complexity and lack of linguistic separation between contexts led to maintenance problems, software coupling, and single points of failure for several other services.

To address these challenges, Creditas’ focus is to modernize all services. Understanding the gains in this strategy, we use the premises of application modernization, the process of updating or transforming legacy applications to make them more efficient, effective, and secure. This involves a number of different steps, such as rewriting the inefficient code, updating the user interface, and improving the inefficient infrastructure. The goal of application modernization is to help organizations keep up with changing business needs and stay competitive.

The application modernization process typically involves the following steps:

• Identify the application’s current state and understand the software needs;
• Create a roadmap for modernizing the application, understanding the budget, and defining goals and objectives.
• Determine the impact and risk to follow, as Refactor, Re host, Retain, Retire, Repurchase, and Re platform.

Creditas adopted a mindset focused on addressing technical debt and breaking down big applications into smaller ones. In particular, we applied the principles of application modernization to our Core monolith, which was reduced to a small service called Home-Core that would be used by the Home business unit. This approach brought several benefits to our organization, including:

• Increased productivity: By allowing developers to work on smaller, more focused codebase, application modernization, and other initiatives increased our productivity in 92% of our pull requests throughput and reduced the cognitive load on our teams.
• Modern infrastructure: By modernizing our infrastructure and moving to Nucleon, our IAC platform, we were able to take advantage of the scalability and flexibility of cloud computing. This not only reduced our costs by almost 85% (decreasing the size of our database and computing) but also improved our security by reducing the risk of data breaches.
• Improved agility: By breaking down our monolith into a smaller service, we were able to create new products and features more quickly and easily. This allowed us to become a more agile organization, we reduced almost 40% of the codebase maintained by our engineering team.

The process of modernizing our Core monolith required the involvement of several people, including business stakeholders, IT professionals, and experts in the relevant context. We used the image below to visualize and plan the different phases of the release, which helped us to create a roadmap for the project.

From the image above, we created our steps to work on small deliveries:

1. Fork the existing shared codebase to a separate repository called Home-Core;
2. Rehost the Home-Core on a modern infrastructure, while still sharing the same database due to the limitations of other existing services;
3. Remove all requests made to the Core and use the Home-Core;
4. Remove code consumed by other products from the Home-Core;
5. Create a new and modernized database and change the Home-Core to use it;

This roadmap outlines the steps we took to move from our monolith to a smaller, more manageable service. The first step was to fork the existing codebase and rehost it on a modern infrastructure, while still sharing the same database across the products. This allowed us to start working on the new service without breaking the existing one, but this created a new necessity, so we started needing to update source code manually and daily to keep both applications synched.

Next, we began the process of changing all requests that were made from the Core to the Home-Core. This required careful planning and coordination to ensure that all products and business units were able to seamlessly transition to the new service.

Once all Home Equity requests were being directed to the Home-Core, we were able to remove the code that was consumed by other products and focus on developing the new service independently. This allowed us to modernize the database and reduce security risks.

Overall, this roadmap provided a clear and structured plan for moving from our monolith to a smaller and more maintainable service. The next steps for the process would be to replicate this in the still existing Core for the other products and contexts across Creditas. In addition, Home can take the next step of splitting the existing Home-Core into microservices based on the different subdomains, allowing for greater agility and flexibility in terms of development and deployment. By following this plan, the company can continue to modernize its services and improve productivity, agility, and security.

Will you join us?

Choose your team to become part of our Crew: https://careers.creditas.com/en