Home › Blog

Cost Reduction

Mainframe application modernization: measure, modernize, prove

Mainframe Modernization: The Best Strategic Investment?

Mainframe application modernization means updating how mainframe applications are reached, developed and run, mostly without moving them. In a 2025 survey of 500 business and IT leaders, 98 percent were moving some applications off the mainframe (Kyndryl). But they were moving 28 percent of their applications on average, and only one respondent planned to leave entirely.

So most applications stay, and the real work is modernizing on the mainframe, where they already run. Companies decide workload by workload which applications stay, and our article on the legacy mainframe explains how.

This work has a price. In the same survey, a modernization project on the mainframe cost $7.2 million on average in 2025 (Kyndryl). A budget of that size needs proof. That proof comes from measuring before the project, acting where the measures point, and measuring again at the end.

Why mainframe application modernization projects struggle to prove their value

When a modernization project ends, the board asks what the money bought. That question is hard to answer when nobody can tie the mainframe bill to one application. Published surveys do not settle it either. IBM surveyed 2,551 IT leaders in 2024, including organizations that had modernized applications on their mainframe. More than 90 percent of them said the work met or beat its budget, timeline and scope (IBM Institute for Business Value).

Kyndryl’s figures give a less positive picture, but they cover all IT modernization, not only the mainframe. In its 2026 report, based on 2,000 business and technology leaders, nearly half of the organizations were behind schedule on their modernization goals (Kyndryl). Only 9 percent fully understood how their applications depend on each other.

Both companies also sell modernization services, so neither figure is neutral. For that reason, a company’s own before-and-after numbers are the only ones its CFO (chief financial officer) cannot dispute.

Three measures to take before the project starts

A modernization project needs three measures, taken before it starts. The first is access, meaning how easily other systems can reach and use an application. The second is performance, and the third is cost. Taken again at the end, the same three measures show what the project brought. Without them, a modernization project looks like a pure cost.

Access comes down to one test. Can a web, mobile or cloud service call the mainframe transaction without changing it? If it cannot, every new channel needs work on the application itself.

Performance tells the team what should stay where it is. The mainframe handles heavy batch work and mass updates well, so performance is rarely the reason to move an application. Response times come from the System Management Facilities (SMF) records that the mainframe already writes. Type 110 covers transactions in CICS, IBM’s transaction server, and type 101 covers the Db2 database.

Cost needs more care, because what to measure depends on how IBM bills the software. Under Advanced Workload License Charges (AWLC), IBM bills on the monthly billing peak, meaning the highest rolling four-hour average (R4HA) of the month (IBM). So the cost measure is when each workload runs compared with that peak. Work that runs outside the monthly billing peak adds little to the bill.

Under Tailored Fit Pricing (TFP) Software Consumption, the bill follows the total MSUs (million service units) used in the year, against a committed baseline (IBM). Unused MSUs carry over to the next year, and use above the baseline is billed at a discounted growth price. IBM sets the baseline from the previous 12 months of production MSU consumption. The bill follows total yearly MSUs against that baseline, so total yearly use is the cost measure.

The data for both models already exists. IBM’s Sub-Capacity Reporting Tool (SCRT) builds its reports from SMF records of types 70 and 89 (IBM). SMF types 30 and 72 then show what each workload uses.

Acting on access: open the applications instead of rewriting them

When other systems cannot call a mainframe application, the usual answer is to open the application, not to rewrite it. The business logic, meaning the work each application does for the business, stays in place. Modernization works on the interfaces first, and the code changes only where a change makes access easier.

APIs (application programming interfaces, which let one program call another) do most of this work. They let mobile apps, websites and cloud services call mainframe transactions without changing the transactions themselves. IBM provides the tools to build them. z/OS Connect creates APIs for z/OS applications and data (IBM). CICS can turn its programs into web services (IBM), and Db2 can expose its data through native web APIs (IBM).

A store that sells through a cloud platform shows the result. Each purchase can go to a mainframe transaction, and the answer comes back in the same flow.

With an API in front of an application, its callers stay unchanged if the implementation later moves. As a result, the IT manager gains a real choice of where each workload runs. That choice matters again at the end, when the measures show that a workload should move.

Opening an application also has a cost. Each new web or mobile channel adds work on the mainframe, and that work adds to consumption. So the team repeats the cost measure after each new channel goes live.

Acting on delivery: where developer time goes

When every change and every new API waits for a few senior developers, opening the applications stays slow. The Australian bank ANZ faced this with its more than 200 mainframe developers. It gave them a choice of IDE (integrated development environment, the tool in which they write code). In eight months, it then set up automatic build, test and deployment for about 40 applications. A hotfix that took about four weeks of effort now takes one hour at most (IBM, which supplied the tools). ANZ found that changing the habits of long-serving developers mattered most, and was not easy. The gain shows in the access measure, because each new API reaches production sooner and no longer waits for a few experts.

Proving the result and funding the next step

At the end of a modernization project, the team measures access, performance and cost again. The gap between before and after is the result of the project, in the company’s own figures. A before-and-after report shows, for each application, the cost and the MSUs used, the share of the monthly billing peak and the response time. Those figures answer the board’s question about what the money bought.

Market figures give a sense of scale, but they do not give that proof. Kyndryl’s 2025 respondents, for example, reported an expected return on investment of 288 percent for modernizing on the mainframe (Kyndryl). The figure was 297 percent for integrating with the cloud, and 362 percent for moving workloads to other platforms. These figures mix very different projects, so they cannot replace a company’s own measure.

A measured saving can then fund the next step. Mainframe FinOps (financial operations, meaning the management of IT cost with data) uses the cost measure for that purpose. Under AWLC, the saving comes from a lower monthly billing peak. Under TFP, lower yearly use keeps consumption under the baseline and leaves room for new work without growth charges. Our comparison of AWLC and TFP explains both models in detail.

Zetaly Automated Capacity (ZAC) manages the monthly billing peak of IBM software billed under AWLC. ZAC typically lowers those software costs by 5 to 20 percent, across more than 30 enterprise deployments. The ZAC Simulator estimates the saving from your own data. You send your SCRT reports and recent SMF samples. Typically within 5 to 7 business days, Zetaly returns your current monthly billing peak, the peak with ZAC, and the expected saving.

When the measures point to a move

Access, performance and cost also show the few workloads that should leave the mainframe. Performance rarely points that way, because the mainframe handles heavy loads well. Cost is the usual reason. Two options can still keep a costly workload in place. Under AWLC, the team can run it outside the monthly billing peak, or manage the peak itself. Under TFP, the option is tuning that lowers its yearly use.

Keep a workload that passes the access test and costs little. Open it with APIs when it fails the test. Move it only when its cost stays high after the options to stay. Our mainframe to cloud migration guide covers the cases where an application should leave the mainframe entirely.

Where Zetaly fits in mainframe application modernization

The three measures need SMF data, and raw SMF records are hard to turn into cost and performance per application without specialist skills. Zetaly works on that data, for the mainframe that stays. Zetaly Data Platform (ZDP) collects the SMF records that the mainframe already writes, whatever the IBM contract (AWLC or TFP). It exposes them through APIs, in the same way that modernization opens the applications. Third-party tools such as Excel and Power BI can then use the data through those APIs, without moving the applications.

Zetaly Service Intelligence (ZSI) builds dashboards from that data, including views by the business categories that each customer defines. These dashboards give the performance and cost measures before and after a project. For software billed on the monthly billing peak, ZAC then lowers the bill, which can fund the next step.

Frequently asked questions

What is mainframe application modernization?

Mainframe application modernization means updating how mainframe applications are reached, developed and run. It can include APIs, modern development tools, AI coding assistants, Java and containers. However, it does not require moving the applications off the mainframe. The business logic stays, while the interfaces and working methods around it change.

Can you modernize a mainframe without migrating off it?

Yes. In a 2025 Kyndryl survey of 500 leaders, only one respondent planned to leave the mainframe entirely. On average, organizations were moving 28 percent of their applications. The Australian bank ANZ, for example, kept its applications on the mainframe. Instead, it changed its development tools and its delivery process, and a hotfix now takes one hour at most.

What should you measure before modernizing a mainframe application?

Measure three things before the project starts. The first is access, meaning whether other systems can call the application without changing it. The second is performance, and the third is cost. Under Advanced Workload License Charges (AWLC), cost follows the monthly billing peak. Under Tailored Fit Pricing, it follows yearly use against a baseline. Measured again, they show the result.

How long does it take to modernize mainframe development?

Published examples give an order of magnitude. The Australian bank ANZ gave its more than 200 mainframe developers a choice of development tools. In eight months, it then set up automatic build, test and deployment for about 40 applications. IBM, which supplied the tools, published these figures. Each project depends on its own scope.

How much does mainframe modernization cost?

Costs vary widely from one project to another. In a 2025 Kyndryl survey, the average cost of a modernization project on the mainframe was $7.2 million, down from $9.1 million in 2024. Integrating with the cloud averaged $6.8 million. Measuring costs before and after the project therefore matters, because the saving can help fund the next one.

How do you prove the return of a modernization project?

Measure access, performance and cost before the project, then measure them again at the end. The gap between the two is the result, in your own figures. Survey figures, such as the expected return of 288 percent that Kyndryl’s 2025 respondents reported for modernizing on the mainframe, mix very different projects. They show possible returns, not your result.

Send your SCRT reports and recent SMF samples. Zetaly estimates your monthly billing peak with ZAC and your saving.