How to Design Infrastructure for a Role-Based Prepaid Money system

Since you're using a microservices architecture, I think that each service should be isolated to make sure that your solution guarantee scalability and maintainability. INMHO these services should be containerized and managed by Kubernetes.

• Frontend Services:
  • Web Applications: The Super Admin Portal, Admin Portal, and B2C Portal should be served by a dedicated frontend service.
  • Mobile Application: A separate service for the mobile app can be deployed with APIs to interact with the backend.
• Backend Services:
  • User Management: Handle user authentication, authorization, profile management, and roles.
  • Transaction Management: Services that handle the processing of prepaid transactions, fund transfers, balance updates, and transaction history.
  • Payment Gateway Integration: Services that interact with third-party payment providers for funding and withdrawal.
  • Notification Service: Manage alerts and notifications (SMS, email, push notifications) for various user actions like successful payments, low balance ....

PostgreSQL should be the central relational database for storing data, but you should consider 2 points :

• Database Clustering and Replication: Use PostgreSQL's built-in replication for high availability and fault tolerance. Set up read replicas for scalability in read-heavy operations, especially for fetching transaction history or user details.
• Separation of Concerns: Use separate databases or schemas for different modules such as user data, transaction logs, etc. This helps in managing performance and scaling each module independently.

For Kubernetes, here is what my reaserach helped me to find:

• Kubernetes Cluster: Host the backend microservices in a Kubernetes cluster, ideally in multiple Availability Zones (AZs) to ensure high availability and resilience.
• Pod Autoscaling: Set up Horizontal Pod Autoscaling (HPA) for microservices to automatically scale pods based on CPU or memory usage.
• Load Balancers: Use Kubernetes Ingress or external load balancers to distribute traffic to your web portals and mobile application APIs.
• CI/CD Pipeline: Implement a CI/CD pipeline for continuous delivery and seamless updates of the microservices. GitOps tools like ArgoCD can automate deployment.

Then you can plan the server distribution as follows:

• Frontend (Web + Mobile):
  • 1-2 servers for load balancing web traffic (for the Super Admin, Admin, and B2C portals).
  • Mobile app API server, managed by Kubernetes pods, can scale based on demand.
• Backend Services:
  • 1-2 Kubernetes clusters with each cluster hosting the microservices.
  • Each backend service should run in its own set of pods, with HPA set to scale the pods based on demand.
• Database Servers:
  • At least 2 PostgreSQL instances (1 primary and 1 read replica) for high availability. You can set up a failover mechanism if needed.
  • Separate database clusters for transactional and non-transactional data if the system grows large.
• Shared Services:
  • A message broker (like RabbitMQ or Kafka) for managing async communication between services like notifications and transaction processing.
  • Caching layer using Redis to store session data, user data, or frequently queried information.

Some links to help you (from where I got inspired) :

Benefits of Microservices Architecture for Banking and FinTech Industries

Is Microservice the Optimal Architecture for Fintech Applications? | by Rohan_157 | Virtual Force Inc. | Medium

Microservices in Banking & Finance: Modernizing Legacy Systems

Payment System Interface Modernization on AWS: Modern Cloud-Native Payment Systems - Payment System Interface Modernization on AWS

Building Payment System Architecture: Comprehensive Guide | Devox Software

Unlocking the Power of Microservices in Financial Systems - TechBullion

Microservice architecture: A transformational change in the financial ecosystem | Fortunesoftit

15-083_e7db671b-12b2-47e7-9692-31808ee92bf1.pdf