Table of Content
Our client operates multicurrency cash settlement systems to settle foreign exchange (FX) transactions among its customers such as central banks, commercial banks, investment banks, and corporations. It works with the real time gross settlement (RTGS) systems of most major currencies to settle FX transactions. Besides supporting major currencies, our client through its systems and technologies standardizes FX operations thereby reducing costs for its customers.
Our client’s foreign exchange currency settlement system comprised of various legacy applications hooking to a proprietary middleware messaging platform. This system had several technical shortcomings which restricted the client’s time-to-market and revenue goals in the following manner:
- Incapability to add new currencies quickly
- Inability to do same day settlement of transactions
- Problematic to process higher volume of transactions
- Difficulty to enhance features for its customers at a faster rate
- Difficulty in maintaining and updating the desktop application
Due to its proprietary monolithic nature the client’s system had following limitations:
- Tight application coupling with a legacy middleware leading to difficulty in adding new applications to expand the feature set quickly
- Maintainability challenges in terms of cost, complexity & legacy nature of the code
- Long release cycles as our client had to rely on the middleware vendor’s schedule to make any changes to it
- Complexity of code as most of the code consisted of non-functional aspects such as recovery, reliability, message sequencing, error handling rather than core functional requirements pertaining to the business
- Scalability issues during peak loads (thread safety compromised when running multiple instances)
In addition to the above issues our client’s customer were using desktop applications for operational users which was difficult to update and maintain. Our client would send update patches to their partners and then the operational users used to install these patches on their desktop application to upgrade the application. The whole process of desktop application upgradation was very inefficient and had lot of gaps. Our client wanted to adopt a system which was simpler, cost effective and could be maintained in a more efficient way. The solution was decided to move from a desktop application to a web based solution which would also provide access to view instructions, payments, accounts and schedules, maintain configuration data and submit system commands to scheduler.
ARCHITECTURE WITH LEGACY MIDDLEWARE
Xoriant was chosen due to its extensive system integration experience with middleware technologies such as TIBCO as well as its banking and FX domain expertise gained through engagements with similar clients. In addition, Xoriant offered a flexible onsite and offshore global delivery model which provided tight account control as well as cost-effectiveness for the client.
Xoriant’s onsite business analysts met the client’s business stakeholders to understand thoroughly the business process reengineering decisions. Armed with the understanding of business end-user requirements, our architects analyzed the current code to design an optimal way to keep certain aspects of the legacy middleware and replace the rest with an industry standard WebSphere MQ as a messaging back bone. This enabled interactions with current legacy applications written in C as well as any newer applications written in other language such as Java/J2EE, PHP, .NET, etc. for immediate extensibility of features. Furthermore, this had the benefit of programmers focusing on developing core functionality rather than on interoperability concerns and recovery/retry/sequencing operations.
Xoriant built a web based solution with a user friendly interface, the web based solution was developed in such a way that the operational users could use the application seamlessly without any ambiguity. The performance of the system also needed to be addressed, as all the users would access the same database through web server without the need of local sync. Considering all the factors Xoriant proposed to develop an application using Google Web Toolkit (GWT), as it provides support for internationalization, cross-browser compatibility, performance, with cost benefit as it is an open source solution. It also facilitates faster UI application development and reusability of the code along with all Java features.
ARCHITECTURE WITH WEBSPHERE MIDDLEWARE
Asynchronous processing of messages was one of the key aspects of the system to settle FX transactions with reliability and scalability. The current system failed to perform at peak loads for same day settlements when there was an increase in settlement volume as well as when there was unpredictable usage spikes that occurred due to sudden currency movements. To overcome these deficiencies, Xoriant enhanced the asynchronous processing system to massively increase the throughput of the messages as well as the reliability and redundancy of the system by implementing design with distributed server architecture, in-memory transactions, and scalable database scheme. Furthermore the new architecture provided high availability through automatic failover to backup systems if there was any failure to process the messages during peak loads. This failover mechanism was a software based solution eliminating expensive middleware dependency.
The other key aspect of the settlement system was ensuring the reliability of database commits. In the current setup while the system was highly reliable the database commit times were slow due to inefficient message passing among various applications, proprietary middleware and the database. Xoriant implemented a two phase commit system with master-slave architecture for redundancy and kept the current data in memory for faster retrieval. This enabled the system to complete transactions without losing data if a failure occurred at either end of the middleware during peak loads or bursts of activity.
Besides these two major enhancements Xoriant engineers also deployed the following improvements to the system:
- Designed the solution to be installed in both managed & non-managed environments
- Replaced custom parsing with standard Swift parsers for Swift messages (MT 202, MT012, MT298, MT019, etc.) to handle FX settlements efficiently
- Developed custom parsers for proprietary message formats such as SIC
- Implemented in-memory eager / lazy loading of reference data for speedy retrieval of data
- Designed the solution for thread safety enabling concurrent access
- For web app, GWT features such as Gin and Guice was used as injector module which enabled late binding. GWT MVP (Model View and Presenter) was used for code modularity of UI application
- Implemented custom widgets(GWT) for web application
- Multi-level database design was adopted to enhance the performance of the web application
- QREP was used to replicate the data from the core database to the database accessed by operational users through the web application
Finally, testing the entire system was a challenge both to make sure the re-engineered code performed to the specifications as well as to guarantee the functionality between the re-engineered code and the older system was identical. For our test strategy, the Xoriant QA team was involved right from the functional requirement phase to obtain inputs from the business analysts and the development leads, thus ensuring comprehensive coverage of test cases across the entire system.
Xoriant automated testing using Junit / Dbunit/ Fitnesse frameworks to test the entire end-to-end system in a timely manner with the overall goal to match the legacy system reliability with improved performance, maintainability, and scalability.
TECHNOLOGIES AND PLATFORMS
The platform was primarily developed using Spring, JPA (Hibernate), JTA, JMS, Quartz, DB2 database and Websphere MQ. VisualVM was used to profile the re-engineered code.
The technical components were designed using standard Java Enterprise technology comprising of Transaction Based Management, Spring managed bean life cycle, JMS, and Core Java. GWT (Google Web Toolkit) was chosen to develop the web application.
Some of the key advantages using the Xoriant team included:
- Project execution in a mixed onsite / offshore model for both tight account control as well cost effectiveness
- Effective reconciliation of technical and business documentation with results from the code analysis due to Xoriant’s domain expertise with FX settlement systems
- Agile software development to support changing requirements
- Automated testing strategies for validating legacy vs re-engineered system outputs
- Usage of software adhering to Java standards
With the re-engineered code, Xoriant achieved several folds increase in performance at peak rates, higher throughputs, richer functionality, more standards based message exchange among various legacy and newer applications. The following is a summary of the important results of the project:
- Eliminated the risk of overwhelming the system for asynchronous processing during peak loads
- Ensured thread safety for the re-engineered application. The application can be scaled vertically (multiple instances on the same machine) or horizontally (multiple instances on several machines)
- Improved maintainability of the code by simplifying the code base by focusing on business logic and separating recovery, reliability, and error handling functions
- Removed vendor lock-in to add features faster by using industry standard API’s like JPA / JTA / JMS
- Optimized complex settlement risk management algorithms during re-engineering of the system
- Increased operational efficiency by developing the web based solution, thus avoiding the time consuming process of upgrading individual desktop applications
Our client with this modular, secure and highly scalable system now has the ability to increase revenue by enabling quick addition of new currencies, providing same day settlements, offering newer features faster.