Large banks and global payments processing companies specializing in commercial transactions processing need to substantially scale the volume of credit card authorizations for mobile and web point of service applications. Typically, their core transaction systems are running on IBM Z CICS, and they usually already have the processing capacity and ability to manage the volume. The challenge is in ensuring that client applications, running on mobile, cloud and web platforms, can process credit card authorizations quickly enough, securely and at volume. The problem is often their outdated mainframe integration solutions are too slow, and result in unacceptable delays for their end-user customers. They think they have mainframe issues, but they don’t – they have integration issues. These companies need help.
Client Background
One such organization is a leading global business payments company that processes transactions for customers in countries around the world. Its portfolio of brands includes companies that automate, secure, digitize and control payments on behalf client employees and suppliers. The firm’s innovative solutions provide value to clients by helping prevent unauthorized employee purchases, enabling better reporting to help businesses manage expenses and cashflow, and reducing fraud. In this industry, it is critical to provide highly responsive service through efficient business processes. Service quality is the primary differentiator and the means of providing customer experiences that foster loyalty.
Slow Card Authorization Process Leads to Customer Churn
The business problem this organization was having was the time a key business process was taking to complete. Authorizing and opening new credit card accounts was taking two or more hours. The service level standard for this process was less than an hour. Authorization was taking so long that in this highly competitive business, some customers were unwilling to wait. The result was lost revenue. The IT team identified inefficiencies in the IT infrastructure that were slowing the process down. The motivation to fix the problem and stop the customer churn and associated revenue loss was very high. During a summer 2021 meeting, the Line of Business leadership directed the IT team to find a better approach.
Root Cause: Screen Scraping Macros
Macros that use TN3270 emulation and screen scraping were the preferred CICS integration method. Macro usage proliferated and business and transaction volumes grew. The scale and inefficiency of screen scraping macros spawned performance issues while adversely affecting mainframe overhead and performance. During peak processing periods, one “macro owning” CICS region grew to over two million transactions per day.
Macro integration inefficiency is often the result of network latency. Macros and their screen scraping logic run off the mainframe. To complete a business transaction, a macro must send a request through the network to the mainframe. Complex business processes often involve a series of mainframe transactions requiring multiple round trips between the macro and the mainframe. The result is typically an accumulation of network latency that to users or customers is an excruciatingly long and unacceptable wait.
“We see this kind of performance impact from screen scraping macros and automations in lots of IT environments,” said Russ Teubner, CEO and co-founder of HostBridge Technology. “The symptoms of this problem present as poor performance, leading many to believe they have a mainframe problem. In reality, it’s a mainframe integration problem. The core business applications that run inside CICS are as efficient, effective, and reliable as ever. But when screen scraping is the integration technology to these applications, performance suffers and blame is usually assigned to the mainframe. The root cause of the problem, however, exists off of the mainframe. The great news is it’s a relatively simple problem to solve using CICS APIs.”
The solution: Replacing Macros with CICS APIs
The organization’s IT team reached out to third-party mainframe vendors with expertise with these types of challenges. One vendor (HostBridge) recommended replacing macros with integration and orchestration CICS APIs and scripts that run on the mainframe inside of CICS. These APIs and scripts exploit features of the CICS and IBM System Z architecture to get CICS application data efficiently, without screen scraping.
Using a JavaScript Engine makes developing and deploying these APIs and scripts easy. A non-mainframe program simply sends an HTTP request to invoke an API or script. The JavaScript Engine executes the full, orchestrated transaction sequence and returns a single response to the requesting application. This approach eliminates virtually all the network latency this customer was experiencing. Furthermore, the APIs live within existing mainframe security infrastructure and will run on the zIIP specialty engine.
Results and Benefits of CICS APIs
To determine how well APIs would perform, the vendor team recommended replacing some of the high transaction volume macros with APIs and scripts. Comparing screen scraping macros to APIs revealed an order of magnitude improvement in performance of the API approach. The benefits this customer is now experiencing include:
- Comfortably meeting service level standards for card authorization and account opening
- Eliminating churn due to a slow card authorization process
- A better customer experience for cardholders
- An advantage over competitors who have slower card authorization processes
- Less mainframe overhead and cost
- A scalable, reliable CICS integration architecture that supports future growth
The payments company now enjoys a scalable, reliable CICS integration architecture that supports future growth. Furthermore, this API approach to CICS integration facilitates agility. The company can quickly and easily address future business requirements using CICS APIs instead of macros. All these benefits are characteristic of using APIs to integrate and modernize CICS applications.
Summary
The HostBridge JavaScript engine (HB.js) proved an ideal solution for scaling this high volume, mission critical, business process. In a matter of weeks, the client was successfully running a prototype workload through HB.js-created CICS APIs. Production deployment took place four short months from the initial design conversation. The HostBridge JavaScript Engine delivers highly scalable CICS integrations through two powerful capabilities: a business level API design approach and CICS-native API orchestration unique to HostBridge Technology.