azampay

A multipurpose android app with end-to-end online payment management solutions.

schedule A Meeting with our Experts

THE CUSTOMER

Azampay is a Tanzanian digital commerce company that is developing a series of products in the East African market. It creates value with the use of tech-oriented business products and services that can benefit businesses and consumers across the region.  
The Project

Overview

  • The project comprised a multipurpose, monolithic Android App with a fully integrated digital Payment Gateway,
  • This Gateway was integrated with over a dozen third-party service providers with multiple financial services:
  • Each of them had their own security configurations,
  • Each of them had their own connectivity models.

Problems

  • With an expanding scope that was diversifying exponentially over time, deployment cycles were longer, cumbersome with larger downtimes.
  • Code maintainability was a major concern, with the code base getting more complex with each iteration.
  • Deploying/fixing new or existing features was impossible without impacting the rest of the system, reducing scalability.
  • Monoliths often rely on a single technology stack, making it challenging to adopt new technologies when needed.
  • A failure at any point in the monolith structure could bring down the entire application.
  • Resource allocation for different components was uniform, rather than dynamic.
  • For development teams, a bottleneck in one area would create delays across the whole project’s progress.

Timesheets

Approvals

Procurement

Folio3’s Solution

Proposition

Our experts proposed switching from a monolithic structure to a containerized, microservice based structure, splitting each business line into its own separate component and creating a modularized structure that separated each feature from the rest.

  • Each module can be deployed independently, making deployments faster, safer and reducing downtime significantly.
  • The code base was simplified with each feature being split into its own module, allowing for better maintainability, writing clean code, clear distinction for the project architecture, easier deployments/bug fixes.
  • Monolithic applications often have limitations in scaling, as they require the entire application to be scaled up together. Microservices allow for more granular scaling, where individual services can be scaled independently based on their specific needs.
  • Microservices enable the use of different technologies for different services, allowing for better technology choices and innovations.
  • Microservices offer fault isolation, meaning if one service fails, it won't necessarily affect the functioning of other services.
  • Monolithic applications may allocate resources uniformly, even when specific components require more resources than others. Microservices allow for more efficient resource allocation by scaling only the necessary services.
  • Microservices can mitigate bottlenecks by decentralizing decision-making and allowing teams to work independently on their respective services.
  • Microservices architecture is well-suited for implementing continuous delivery and continuous integration practices, which can streamline the development and deployment process.
  • Microservices can be designed with redundancy and failover mechanisms, improving the overall resilience of the system.
  • As the application grows and evolves, a microservices architecture can better accommodate new features and changes. It provides a more scalable foundation that can adapt to the needs of the business over time.

Each service is represented as an isolated bounded context and deployed as a containerized instance using Jenkins CICD pipeline automation. This has eased up the process to release updates for individual services while keeping the rest of the systems running.

Implementation

For payment transactions, multiple banks, telecommunication company APIs, and ERPs were integrated, each with a separate communication and security structure. Hence, developing the communication modules for each of these third-party services as microservices provided the flexibility to deploy them separately without affecting each other and on a relevant server.

Each service is represented as an isolated bounded context. It was then containerized using Docker and deployed using the Jenkins CI/CD pipeline automation. This has eased up the process to release updates for individual services while keeping the rest of the systems running.

Schedule A Free Consultation

Technologies Involved in Case Study