Building a trustworthy and stable digital banking platform

The Project:

A digital banking platform that simplifies things by allowing banks to re-invent their products, processes, and operating models in a single, cloud-capable, API-based, transactional, saving, and lending core. It provides over 30 supporting services such as decisioning, workflow, document management, financial ledger, and product configuration.

All functionalities can be coupled with our adaptable web/mobile web/native front-end. In addition, our API gateway can be utilized to create a marketplace for 3rd party application and service integration.

About the Client:

The client provides funding, professional services, and resources to several businesses across the financial services and hospitality industries.

Architecture:

The platform use of microservices and event sourcing gives it a unique architecture to compete in the new world of Fintech.

Each service is focused and hence lends itself to doing things autonomously. Therefore by building products/modules (the microservice), rather than projects, teams can focus on building business functionality rather than focusing on technology. This results in services that are adaptable in multiple contexts.

The same service can be reused in more than one business process or over different business channels depending on the need. Each team is responsible for a particular service. This approach lends itself to the creation of smart cross-functional teams.

On top of this, event-sourced system has more advantages:

• An event-sourced system states that the state of a system is the sum of all the events that led to that state. This is particularly suited to financial systems as when an event is emitted it is stored in an append-only “event store”.
• Hence all events are stored, and every event that leads to a state (such as current balance) is “auditable” and traceable as a “state” of, for instance, an account. It is not persisted/saved but derived directly from the sum of the events that led to that “state”.
• In conjunction with the CQRS (command query responsibility segregation) pattern, event sourcing allows microservice/s to issue commands to write to a store and for other microservice/s to “listen” to these written events and allow for queries/“reads” from this microservice.
• This combination of write to the event store/s and for a read of events from the event store, allows multiple projections or views to be implemented. The projections are decoupled completely from the write microservice.
• Different storage systems (NoSQL or relational etc.) can be implemented for each projection, and scaled accordingly.
• Event stores are also asynchronous which means that locking and volume issues are eliminated.

Technologies:

• Most of the backend services are written in Java 11 and Spring Boot, while the frontend is using Angular
• MariaDB is used as the main database in most of the services, as well as the event store
• For streaming events, we are using Kafka
• For Saga orchestrating, we are using Camunda
• KeyCloak - identity service
• DevOps technologies - Docker, Kubernetes, OpenShift, Jenkins

Goal:

We are involved in the whole development life cycle of the product including:

• Introducing new features, enhancing and stabilizing existing features
• Investigation and coming to the optimal solutions for specific client’s requirements together with the dedicated team of business analysts
• Involved in the process of customers onboarding from data migration to system enhancements and adjustments with a set of configurations and system setup to address specific requirements of new customers.
• Delivering the final product to the client and maintaining the solution

The Team:

The team consists of six software developers, and it’s expanding.

Over time, our responsibilities have expanded from purely development roles to implementation specialists who listen to the needs of our clients to come up with an optimal solution.

Also, our team is assigned with optimizing and managing the scrum process, maintaining code quality through the code review process, as well as assessment of the tasks complexity and the distribution of responsibilities within the team.

Solution:

We developed multiple new microservices and improved the old ones, so they can together meet any clients’ needs. We also started refactoring the frontend towards more flexible micro-frontend architecture.

Results:

During the development process, we exceeded expectations with fast delivery time and the improvement of the development process.

We were able to successfully deliver the product to multiple clients that are using the solution to serve the daily needs of thousands of customers.