Microservices in financial services

In today’s hyper-competitive business environment, enterprises need to respond quickly to changing market conditions and customer needs. Financial Services organizations in particular need to constantly deliver new capabilities and services that are customer-centric, market-driven, and compliant with contemporary regulatory regimes. Needless to mention, they need to quickly deliver new capabilities and must never compromise on security, reliability, or scalability. The microservices architectural paradigm is ideal for delivering net-new and incremental functionality quickly, reliably, and with minimal side effects.

What are Microservices?

Microservice architecture is a design paradigm that facilitates the development of software composed of small, independent services that cooperate via well-defined APIs and lightweight protocols. As opposed to micro-frontends, which split the application UI into loosely-coupled frontends, the idea of microservices is to expose application backend functionality via discrete services that can be developed, tested, tuned, and deployed independently.
This novel approach to application development leverages containerization, modern DevOps, Continuous Integration/Continuous Deployment (CI/CD), and automated testing to deliver high-quality services in highly compressed timeframes.

Today, many organizations are developing enterprise-grade service-oriented applications using the microservices architecture pattern. This style of application structure combines highly maintainable, loosely coupled, independently deployable services with concepts from service-oriented applications (SOA), containerization, and DevOps all rolled into one.

A major benefit of microservices is that they can be built by small, agile, autonomous, cross-functional teams with independent CI/CD pipelines and rolling rollout policies.

Example of a Microservices Architecture
Example of a Microservices Architecture

Benefits of Decomposing Applications

Much like micro frontends, microservices decompose applications into smaller, decoupled, and independent services that deliver discrete, well-articulated business functionalities. Microservices naturally avoid the problems caused by large, highly intertwined, and difficult-to-test codebases that are typical of monolithic applications.

Microservices outclass monolithic structures in numerous ways. With monolithic structures, applications are tightly coupled and typically run as a large, complex single service. If a single application process needs to be scaled, the entire application must be scaled. The same goes for testing and release management. Microservices, on the other hand, allow developers to frequently update small, granular parts of an application without impacting the entire environment. This enables a higher degree of scalability and flexibility. Microservices expose lightweight APIs, with each business capability being backed by a dedicated service that performs a single, related set of functions.

Monolithic vs Microservices Architecture
Example of Monolithic vs. Microservices Architecture

The microservices architectural pattern simplifies application testing because the code is not as interdependent and intertwined as that of monolithic structures. Engineering teams can be composed more dynamically and flexibly by leveraging technology and business domain skills that are highly specific to the services being developed. Microservices can be written in multiple programming languages and organized by business capability.
By adhering to the Single Responsibility Principle, a design principle that mandates that a single component of a system must encapsulate and be responsible for a single quantum of functionality, microservices lend themselves to faster development, easier testing, and more agile deployment with minimal side effects.

An additional useful design principle that is relevant here is the Common Closure Principle (CCP) the effectively states that– if the business demands a service change, developers only need to update a single component or package. This paradigm ensures that the impact of a single change will be limited to a single service.

Microservices are especially suited to containerization, thereby facilitating orchestration and cloud-based deployment.
Isolation is another key benefit of the discrete nature of microservices. Be it the proper implementation of domain-specific security policies, use of case-specific hardware optimizations, or application-specific scaling, microservice architectures can easily facilitate such domain-specific tuning, deployment, and management.
Microservices also enable developers to implement software development design patterns that decompose a problem into the repository, domain, service, and UI architectural layers. Such designs naturally produce software that is more reusable, and easier to maintain and support across enterprises.

How Granular Should a Microservice Be?

The granularity of a microservice depends on the functionality being delivered. Microservices can be domain-specific, infrastructure-oriented, or operationally focused. An excellent example of domain-specific microservices is the Open Banking API which defines industry-standard APIs for banking functions such as balance transfers, balance inquiries, Wire transfers, ACH payments, etc. These APIs have been implemented by all the leading banks and are helping drive innovation and modernization in Banking. The granularity of these APIs is designed to faithfully reflect the business semantics of the operations and aligned to the boundaries of the business transactions.

As a rule of thumb, microservices must strike a balance between being too finely grained, in which case they will introduce too much network traffic, and too coarse-grained, in which case they will likely break the Single Responsibility Principle.

Microservices in Financial Institutions

Financial Services organizations have pioneered several technological advances in the areas of trading, instrument pricing and valuation, portfolio management, and wealth management, among others. However, while service-oriented architectures have long been deployed successfully in Capital Markets, Banking, and Wealth Management, they are, by and large, not architected as true microservices. Today, these organizations across the globe are engaged in digital transformation initiatives which include UX modernization, microservice architectures, containerization, and cloud-native deployment.

Microservices enable Financial Services organizations to stay abreast of technological innovations, customer trends, market dynamics, and regulatory regimes, all with an eye on delivering enhanced customer experiences, reduced cost, and ultimately, better shareholder value.

An example of how microservices enable innovation in the payments space is the European Union’s Revised Payment Services Directive (PSD2) which promotes integrated payment and information services, improves customer experience, and provides access to a wealth of customer information and insights. Key provisions of PSD2 include Strong Customer Authentication, reduced fraud rates in the industry and increased trust with consumers, and enhanced online banking and payment options for e-commerce consumers.

Firms that adopt a microservices-driven architecture to deliver on this directive can benefit in a variety of ways, including phased deployment, enhanced interoperability, enhanced testability, and ultimately, enhanced ease of adoption.

Microservices and Desktop Integration – the Promise of Glue42

There are obvious benefits of microservice architectures to Desktop Integration Platform design owing to enhanced back-end performance. However, there are important and perhaps less obvious benefits – well-defined API interfaces that faithfully represent business transaction boundaries can actually enhance the overall user interface design by enabling more business-native workflows. This in turn promotes enhanced ergonomics, ultimately enabling the end user to form cognitive mental models that more closely reflect the nuances of the underlying business processes. This subtlety results in greater end-user productivity, lowered error rates, and reduced financial impact.

How to Prepare for a Shift from Monolithic Architecture?

Facing unprecedented challenges in a complex digital transformation process is inevitable. Business leaders must ensure that their teams are ready to adopt modern agile working practices and new ways of decomposing business problems.

Several modern toolkits have been developed from the ground up to support microservice architectures. Frameworks such as Quarkus, Node JS, and Micronaut provide excellent tooling for implementing microservices and deploying such architectures with unprecedented agility.

Product managers, architects, developers, and quality assurance professionals must consciously re-orient their mental models toward microservice orientation if they are to succeed at it. This must be reflected in API design, component design, database design, testing regimens, and application deployment.

Prashanth Nandavanam
Author Details

Prashanth Nandavanam

US Operations Director

Prashanth Nandavanam is the United States Operations Director at Glue42. He is an experienced technology and domain expert in Capital Markets, Wealth Management, and Investment Management. At Glue42, he is responsible for customer success, innovation, and delivery in the United States.