Refactoring and Optimizing a Banking App

Given the app’s complex infrastructure, implementing all changes at once wasn’t an option as it would have extended the stabilization period in production. To avoid this, we followed an incremental approach, breaking the project into smaller parts. This allowed us to gradually expand functionality while ensuring stability and delivering faster results for specific improvements.

Part 1. Stabilization

Before any major upgrades, we had to bring the app to a reliable state. Our first step was eliminating critical errors to ensure stable performance. We could only move forward after securing this solid foundation.

Part 2 (a). Enhancing the app’s functionality

With the app stabilized, we shifted our focus to upgrading its functionality while simultaneously working on refactoring and performance optimization—covered in Part 2(b). We structured the scope into phases, which allowed us to refactor the code while enhancing or replacing certain modules.

The planning stage had the following steps:

• Defining the architecture and database structure
• Gathering requirements based on the existing code and functionality 
• Planning backend team tasks to create the new architecture
• Collaborating with a DevOps expert to build the new infrastructure
• Writing database migration scripts

Next, we moved into development, setting high code quality standards. Our team improved the app’s functionality and interface to align with the client’s new product goals:

• To increase the inflow of money into the app, we developed a new version of API services and improved the UI/UX, making wallet top-ups more visible and intuitive.
• To expand spending opportunities and boost transaction volume, our team enabled wallet-to-wallet transfers for effortless peer-to-peer transactions. Now, users can easily enter an amount, generate a QR code, and have another user scan it for an instant fund transfer. 

To encourage daily payments, we introduced a passcode for faster authentication. Our team also expanded top-up and spending locations and implemented new notifications nudging customers toward frequent app usage.

On top of that, we ran functional and load tests and integrated SonarQube to assess test coverage and ensure code quality. 

Once everything was ready, we prepared the upgraded functionality for rollout to production. The patterns and templates we created during this phase can be easily reused when upgrading other app features.
All these changes were supported by crucial code and performance enhancements, which our team worked on in parallel.

Part 2 (b). Refactoring and performance optimization

While working on the feature-related tasks, we also optimized the app’s architecture and rewrote the old code.
Refactoring was a must because the code had significant performance issues that could no longer be patched with hotfixes. Additionally, the lack of code monitoring in production made it difficult to assess the project’s true state.

The scope of our work included: 

• Developing a new backend (v2) to support the upgraded functionality
• Encapsulating wallet and authentication services for the upgraded features to make them more flexible and scalable
• Implementing a new architecture for upgraded features designed to handle increased loads 
• Rewriting old code to use it for new features and integrating it into the new architecture
• Setting up code monitoring with Sentry as a quick fix before integrating more sophisticated tools
• Using Apache Kafka to improve the performance

Our collaboration on this project lasted four months, with a team of two backend developers and a DevOps expert handling the work.