In COBOL environments, runtime-based licensing imposes recurring costs each time an application is executed—costs that persist well beyond the initial compiler purchase. While initially tolerable in controlled, limited use environments, runtime-based licensing fees become increasingly burdensome as organizations adopt containerization, scale across hybrid infrastructures, or deploy applications in dynamic production ecosystems. Fortunately, there are modern alternatives that eliminate these costs without requiring a full system rewrite.
When Licensing Models Inhibit Engineering Progress
Traditional runtime-based licensing charges based on metrics like CPU cycles, concurrent users, transaction volume, or execution frequency. As a result, every new deployment or usage spike comes with a financial penalty—often one that’s difficult to predict in advance.
This model may have aligned with static, monolithic applications decades ago, but it creates friction in modern delivery pipelines. Continuous integration and automated testing introduce frequent executions. Containerized workloads spin up and down dynamically. Microservices may call COBOL logic thousands of times per hour. All of this means that the cost of running your software can quickly eclipse the cost of developing it.
During periods of market volatility, transaction volumes can surge dramatically. For example, on April 7, 2025, the National Securities Clearing Corporation (NSCC) processed 545 million transactions—a 33% increase over its previous peak in 2021. (DTCC 2025)
In systems where licensing models tie runtime fees to execution volume, these spikes can lead to sudden and significant cost increases. For organizations relying on COBOL-based systems to handle large volumes of mission-critical transactions, the financial impact of such usage-based licensing can be both substantial and difficult to forecast.
The Operational Cost of Uncertainty
The problem isn’t just financial—it’s architectural. When runtime costs are variable, they affect how decisions are made across engineering, finance, and operations. Teams become reluctant to containerize or migrate workloads when every move raises questions about licensing exposure. Deployment frequency is throttled to avoid triggering new fees. And modern development patterns—like autoscaling or dynamic routing—become cost centers rather than efficiency gains.
This undermines the core goals of modernization: flexibility, velocity, and cost efficiency.
What Fixed-Cost Licensing Enables
Eliminating runtime fees means reclaiming control over how, where, and how often you run your applications. A fixed-cost licensing model simplifies budgeting, decouples technical decisions from licensing constraints, and supports continuous delivery practices without financial penalties.
That’s the approach we’ve taken with NetCOBOL: a zero-runtime-fee COBOL compiler backed by decades of enterprise deployment and supported by Fujitsu. With NetCOBOL, there are no charges for application execution—whether it runs once or a million times across environments.
A Cleaner Path Forward
Runtime fees force organizations to optimize around cost, not code. That misalignment slows delivery, inflates overhead, and limits your ability to evolve with the business.
By moving to a fixed-cost compiler like NetCOBOL, you remove those constraints—so your infrastructure, your applications, and your team can scale freely.
Learn more about Fujitsu NetCOBOL