The current state of mainframe application development
Mainframe CI/CD involves applying automated Continuous Integration (CI) and Continuous Delivery/Deployment (CD) practices to mainframe applications, enabling faster, more reliable code changes through integration with modern DevOps tools like Git, Jenkins, and GitLab.
Mainframe application development is a critical function in many large enterprises, especially in industries like finance, government, and healthcare. Most mainframe environments still rely on monolithic codebases, manual deployment steps, and waterfall-style development processes, which can lead to long release cycles and limited agility.
However, DevOps practices are pushing organizations to evolve their mainframe development processes. CI/CD adoption is growing as companies look to unify toolchains, reduce operational risk, and make their mainframe environments agile.
Steps to implement a mainframe CI/CD pipeline include:
- Set up version control: Commit mainframe code to a Git repository.
- Configure an orchestrator: Choose and configure a CI/CD orchestrator like GitLab CI, Jenkins, or GitHub Actions.
- Connect to the mainframe: Establish a connection from the orchestrator to the mainframe environment.
- Automate builds: Use tools like IBM DBB within the pipeline to automate the build process for mainframe code.
- Implement automated testing: Integrate automated testing to ensure code quality.
- Define a branching strategy: Implement a strategy for managing code changes across development, test, and production branches.
- Iterate and measure: Adopt a phased approach, starting with pilot projects, and continuously measure progress using key metrics to demonstrate success.
This is part of a series of articles about mainframe modernization.
Benefits of CI/CD for mainframe development
There are several reasons that organizations use Continuous Integration/Continuous Delivery for developing mainframe applications:
- Faster delivery: Delivers code changes more frequently and reliably.
- Improved quality: Catches bugs earlier through automated builds and tests.
- Enhanced collaboration: Standardizes development workflows, fostering better communication between mainframe and distributed teams.
- Agile development: Enables mainframe teams to adopt Agile and DevOps methodologies.
- Modernizing talent: Lowers the entry barrier for new developers by enabling the use of industry-standard tools.
- Reduced manual effort: Automating build, test, and deploy processes eliminates time-consuming manual tasks, freeing developers to focus on business logic and innovation.
- Improved auditability: CI/CD pipelines produce consistent logs, audit trails, and reports.
- Better integration with cloud-native services: CI/CD enables mainframe applications to be developed and deployed in sync with distributed applications, supporting hybrid and API-driven architectures.
- Rapid feedback loops: Developers get immediate insights into the impact of their changes, shortening development cycles and reducing the cost of fixing defects.
- Standardization across platforms: Unified pipelines and shared tooling make it easier to enforce coding standards, reuse components, and align mainframe practices with enterprise-wide DevOps initiatives.
Core principles of CI/CD applied to mainframe environments
Applying CI/CD to mainframes involves adapting modern DevOps principles to environments optimized for reliability and transaction integrity. The goal is to bring automation, consistency, and rapid delivery to mainframe development while maintaining the system’s high standards for security and uptime.
1. Continuous Integration (CI)
Developers frequently integrate code changes into a shared repository, triggering automated builds and tests. On mainframes, this requires integrating source code management tools such as Git with traditional mainframe compilers and testing frameworks. Automated build pipelines validate COBOL, PL/I, or Assembler programs, ensuring code quality and compatibility before changes reach production.
2. Automated testing
Automated testing is critical to maintain reliability. Mainframe CI/CD pipelines include unit, integration, and regression tests that run automatically after each build. Modern tools enable mainframe applications to be tested using the same frameworks as distributed systems, ensuring functional consistency across platforms.
3. Continuous Delivery and Deployment
Mainframe pipelines automate packaging, promotion, and deployment of applications across environments: development, test, staging, and production. Deployment automation minimizes manual intervention and reduces the risk of human error. Rollback mechanisms and blue-green deployment patterns are increasingly supported in mainframe ecosystems, enabling safe and predictable releases.
4. Infrastructure as Code (IaC)
Mainframe configurations, such as datasets, JCL scripts, and middleware setups, can be version-controlled and automated using IaC principles. This ensures consistent environment setup, faster provisioning, and improved traceability.
5. Monitoring and feedback
Real-time monitoring and feedback loops close the CI/CD cycle. Metrics such as build success rates, test coverage, and deployment times provide insights into process efficiency. On mainframes, system performance and transaction integrity are also tracked to ensure deployments do not affect service levels.
6. Collaboration and transparency
CI/CD practices encourage cross-platform collaboration between mainframe and distributed teams. Shared repositories, automated pipelines, and unified dashboards provide transparency, enabling faster issue resolution and consistent delivery standards across the enterprise.
Tony Kelly is a DevOps marketing leader who drives innovation and awareness of the latest trends in Continuous Delivery.
Mainframe-specific challenges in CI/CD
While CI/CD can provide major benefits to mainframe development, it also presents multiple challenges, because mainframes were not originally developed with CI/CD processes in mind.
Legacy systems compatibility
Mainframes often run decades-old applications built with outdated languages and proprietary tools, complicating their integration into modern CI/CD workflows. These legacy systems may lack support for modern APIs, source control, or automation interfaces, making it difficult to adopt contemporary tooling. Upgrading or wrapping legacy applications to interact with modern DevOps systems can require significant custom development and a deep understanding of both legacy and new technologies.
Another complexity arises from the need to preserve existing investments and maintain backward compatibility. Many mainframe-based processes are critical to day-to-day business operations, which makes refactoring code or replacing legacy components risky. Change management becomes a slow, careful process, and organizations must balance the pace of modernization against operational continuity to avoid system failures or business disruption.
Cultural shifts and workforce skills
Transitioning mainframe teams to embrace CI/CD demands substantial cultural change. Mainframe professionals may be accustomed to waterfall processes and manual code promotion routines, which differ from the agile, fast-paced methodology of CI/CD. Getting buy-in for automation and iterative delivery often requires overcoming skepticism and resistance to change.
Developing workforce skills for modern mainframe DevOps is another significant hurdle. Many organizations face a shortage of mainframe experts familiar with automation, cloud integration, and modern CI/CD tools. Upskilling developers, integrating cross-functional teams, and investing in training are necessary for successful transformation. This investment ensures that teams can not only maintain legacy systems but also adapt to emerging best practices in software delivery.
Security and compliance in regulated industries
Security and regulatory compliance are major concerns in mainframe environments, especially in sectors like banking, healthcare, and government. Mainframes often process and store sensitive data, so organizations must ensure that automated pipelines adhere to rigorous security policies and audit requirements. Integrating security controls and compliance checks into CI/CD processes can be challenging, as every release must be validated for policy adherence and legal mandates.
Moreover, mainframe systems typically interact with a complex web of external and internal services, raising the stakes for potential vulnerabilities. Automating security testing, code scanning, and compliance reporting is essential to mitigate risks and maintain trust. Establishing a secure CI/CD process on the mainframe requires continuous collaboration with InfoSec teams and a “shift-left” approach, embedding security early into the development lifecycle.
Integration with enterprise DevOps ecosystems
Integrating mainframes with modern DevOps ecosystems requires bridging the divide between traditional mainframe tooling and contemporary platforms used in distributed environments. Mainframes may rely on unique build systems, proprietary scheduling, and legacy interfaces, creating obstacles for integration with widely used CI/CD tools such as Jenkins, Git, and automated testing frameworks. Interoperability can be achieved through adapters, APIs, and middleware, but this increases the complexity of the overall DevOps pipeline.
Another challenge is creating a unified DevOps experience where mainframe and distributed teams can collaborate seamlessly. Standardizing processes and sharing artifacts between platforms ensures consistent quality and accelerates delivery. However, differences in deployment patterns, release management, and workflow automation often necessitate bespoke solutions, adding to project timelines and resource requirements. Coordination and clear communication between mainframe and non-mainframe teams are essential for successful integration.
Best practices for implementing CI/CD practices in mainframe development
1. Standardize development and deployment pipelines
Establishing consistent development and deployment pipelines across all mainframe applications is the foundation for reliable CI/CD. Start by defining uniform build, test, and deployment stages using automation tools compatible with mainframe environments. Align these pipelines with enterprise standards for version control, branching, and release management. This ensures that every application follows the same process for validation and deployment, reducing errors caused by ad hoc scripting.
Automating traditional tasks such as compiling COBOL or JCL execution through tools like Jenkins or IBM UrbanCode Deploy helps integrate mainframe delivery into broader enterprise workflows. A standardized pipeline also simplifies onboarding for new developers and improves visibility for all stakeholders.
2. Invest in automated testing coverage
Automation must extend beyond builds to include testing. Develop layered testing frameworks that cover unit, integration, regression, and performance testing for mainframe applications. Automate these tests to run as part of every pipeline execution to ensure that defects are detected early.
Use modern testing tools that support mainframe technologies and integrate them with distributed testing environments to validate end-to-end workflows. Test data management should also be automated to provision consistent datasets across environments. The goal is to move from manual validation toward continuous quality assurance, ensuring that any change, no matter how small, is verified before release.
3. Adopt incremental modernization instead of Big Bang
Modernizing mainframe CI/CD should be approached as an incremental process rather than a full replacement. Prioritize automation and modernization of specific workflows or applications with high business value. Start by integrating source control systems, then gradually introduce automated builds and deployments.
Incremental modernization reduces risk and avoids disrupting critical production systems. It also enables continuous learning, where teams can refine tools and processes based on early successes. Over time, incremental improvements build a robust DevOps foundation without requiring massive upfront investment or exposing the business to operational downtime.
4. Ensure security is integrated early (shift-left security)
Security should be part of every stage of the mainframe CI/CD pipeline, not an afterthought. Embed automated code scanning, compliance checks, and vulnerability assessments early in the build process. Integrating tools for static and dynamic analysis ensures that security issues are identified and remediated before deployment.
Establish clear policies for access control, change tracking, and audit logging to maintain compliance with industry regulations. Work closely with InfoSec teams to define secure coding standards and automated enforcement mechanisms. Adopting a shift-left approach not only improves system resilience but also reduces the cost and complexity of fixing vulnerabilities later in the delivery cycle.
5. Enable collaboration across mainframe and distributed teams
Successful CI/CD on mainframes requires breaking down silos between mainframe and distributed development teams. Use shared repositories, common dashboards, and unified workflow tools to ensure transparency and collaboration. Implement communication channels and review processes that allow cross-platform visibility into builds, test results, and deployments.
Encouraging cross-functional teams helps align development practices, speeds up issue resolution, and fosters a DevOps culture of shared ownership. Unified tooling and shared metrics also help synchronize release cycles across heterogeneous environments, improving delivery cadence and consistency.
6. Provide continuous training for mainframe developers
Continuous training ensures mainframe teams remain current with modern DevOps practices and tools. Developers should be trained on version control systems like Git, CI/CD orchestration tools, and automation frameworks relevant to mainframe environments.
Pairing experienced mainframe engineers with DevOps practitioners fosters knowledge exchange and accelerates adoption of new practices. Regular workshops, internal labs, and certification programs keep skills up to date, reducing resistance to change and increasing team confidence in automated workflows. Over time, this builds a workforce capable of maintaining legacy systems while driving modernization forward.
Help us continuously improve
Please let us know if you have any feedback about this page.
