A global payments processing company specializing in commercial transactions processing needed to substantially scale the volume of credit card authorizations for mobile and web point of service applications. With their core transaction systems running on IBM Z CICS, this HostBridge customer already had the processing capacity and ability to manage the volume. The challenge was in ensuring that client applications, running on mobile, cloud and web platforms, could process credit card authorizations quickly enough, securely and at volume. The company turned to HostBridge for help.
The customer 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 customer 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.”
HostBridge Recommends Replacing Macros with CICS APIs
This customer’s IT team reached out to HostBridge Technology, who was very familiar with the problem this customer was experiencing. The HostBridge team 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.
Results and Benefits of CICS APIs
To determine how well APIs would perform, the HostBridge team recommended replacing some of the high transaction volume macros with HB.js APIs and scripts. The customer identified candidate macros for a prototype project. In just a few weeks, HB.js was installed and APIs were developed, deployed, and tested. 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
This 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 HB.js to integrate and modernize CICS applications.
Reach out to us using the contact information below to learn more about using CICS APIs or to discuss prototyping HB.js for CICS API development.