The Mainframe Paradox: Why Modern Infrastructure Still Relies on the Refrigerator

In this conversation, Skyla Loomis, General Manager of IBM Z Software, maps the role of the mainframe in a cloud-native world. The core idea is that mainframe relevance is not about legacy code, but about data gravity and full-stack optimization. As distributed systems grow in complexity, the scale-up model of the mainframe becomes a competitive advantage for performance and regulatory compliance. This analysis is useful for enterprise architects and CTOs who are struggling with the hidden costs of distributed sprawl, as it offers a way to integrate high-resiliency systems to gain an advantage in speed and security.

The Hidden Cost of Scale-Out Complexity

Modern infrastructure is focused on distributed scale-out models. However, Loomis notes a downstream effect: moving data away from the system of record introduces latency, security risks, and compliance overhead. When organizations treat the mainframe as a legacy problem to be solved through migration, they often create a distributed environment where data must be constantly synchronized and protected across different locations.

There is really a gravity that forms around these platforms where clients already have these existing workloads and so anything that needs to take advantage of that transactionality or the data that you may already have there is where you really want to keep extending and leveraging the platform versus trying to create a replica somewhere else.

-- Skyla Loomis

The system responds to this migration by forcing teams to build complex middleware to manage the resulting data fragmentation. Loomis points out that the mainframe scale-up architecture avoids this by keeping the compute and data in the same high-resiliency environment. The competitive advantage here is the ability to perform complex tasks, like fraud detection, at the exact moment of transaction, without the network latency that affects distributed alternatives.

Why Obvious Fixes Create Operational Debt

Conventional wisdom suggests that modernization is a language swap, such as moving from COBOL to Java or Python. Loomis argues this is a surface-level view that ignores the systemic reality. The bottleneck in enterprise software is not the syntax of the language, but the lack of documentation, the tangled dependencies of legacy applications, and the friction of outdated developer tools.

Replacing COBOL with Java without addressing the underlying toolchain simply moves the same tangled ball of string into a new language. Loomis notes that the real unlock is modernizing the developer experience using VS Code, Jenkins, and CI/CD pipelines while keeping the core logic on a platform optimized for that specific workload.

What AI does is it helps give you that x-ray vision into that application. It now empowers the developer to not be afraid to find that dead code and cut it out and not be afraid to rearchitect this section of the application.

-- Skyla Loomis

This reveals a deeper truth about systems thinking: the payoff of modernization comes from visibility and confidence, not from the language itself. By using static analysis as a precursor to AI-driven insights, teams can map the interconnections of their systems, allowing them to refactor with precision rather than ripping and replacing, which is where most enterprise projects fail.

The 18-Month Payoff: Cultural Over Technical Shift

The most significant barrier to mainframe modernization is not technical, but cultural. Loomis emphasizes that teams can deploy code 20 times a day on a traditional ZOS banking app, but only if they commit to the difficult work of changing the developer culture. This is a durable investment; it requires retraining staff and integrating modern workflows into a proprietary environment.

This creates a competitive moat. Because most organizations are unwilling to do the heavy lifting of integrating modern CI/CD into a mainframe environment, those that do gain an advantage in agility and operational resilience. The payoff is a long-term investment in a platform that becomes more cost-effective as you run it hotter and denser, effectively turning the mainframe into a private, high-performance cloud.

Key Action Items

• Audit for Data Gravity (Immediate): Identify core transactional workloads where data is currently being copied out to distributed systems for processing. Calculate the total cost of egress, synchronization, and security compliance for those copies.
• Modernize the Toolchain (Next Quarter): Instead of focusing on language migration, prioritize moving the developer experience for mainframe teams to modern standards (VS Code, Git, Jenkins, Ansible). This pays off in 6-12 months by reducing the fear of modifying legacy code.
• Implement Static Analysis (Next Quarter): Before applying generative AI to codebases, deploy static analysis tools to map application dependencies. AI models require this declarative context to be effective; without it, they are prone to errors.
• Consolidate Databases (6-12 Months): Evaluate workloads currently running on x86 for high-density database needs. Investigate Linux on Z for consolidation; the potential for 50%+ power and license cost savings, combined with improved cyber-resiliency, creates a long-term ROI.
• Adopt an Interoperability-First Architecture (Ongoing): Stop viewing the mainframe as a silo. Use REST APIs and Kafka to treat the mainframe as a native participant in your hybrid cloud. This prevents the rip and replace trap and allows for incremental, low-risk modernization.