Portable and Secure CI/CD for COBOL: Lessons from an Industrial Migration
This paper presents a case study of Bankdata's successful migration of a fragile, vendor-locked Jenkins-based COBOL CI/CD pipeline to a containerized, abstracted architecture, which reduced execution time by 82% and provided a scalable model for modernizing legacy systems in regulated environments.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine a massive, ancient bank vault that has been running the world's financial systems for decades. Inside this vault, the machinery is made of COBOL, a programming language as old as the banking industry itself. It's incredibly reliable, but it's also heavy, slow, and requires a very specific, old-school key to open the doors.
For years, the team at Bankdata (a cooperative that runs banking systems for Danish banks) used a tool called Jenkins to manage how they updated this ancient machinery. Think of Jenkins as a very powerful, but finicky, robotic foreman.
The Problem: The "Fragile Foreman"
The old system worked, but it was like a house of cards.
- Too Many Rooms: The instructions for the robot were scattered across four different filing cabinets (repositories). If you wanted to change one thing, you had to run between all four cabinets.
- The "Just-in-Time" Problem: Every time the robot started a job, it had to stop and run to the hardware store to buy the specific tools it needed (installing dependencies). This made the process slow and inconsistent. Sometimes it got the wrong tool, and the whole job crashed.
- Vendor Lock-in: The robot only spoke "Jenkins." If the company ever wanted to switch to a different robot brand, they would have to rebuild the entire factory from scratch.
- Security Risks: Because the tools were bought on the fly, there was a risk of bringing in a rusty or dangerous tool that could compromise the vault.
The result? Updates took 12 minutes (724 seconds), were hard to fix, and kept the developers stressed.
The Solution: The "All-in-One Toolbox"
The team decided to migrate to a new system called GitHub Actions (a different, modern robot brand). But they knew they couldn't just swap the robot; they had to redesign the whole workflow.
Here is how they did it, using simple analogies:
1. The "Universal Translator" (Abstraction Layer)
Instead of writing instructions that only the old Jenkins robot understood, they built a Universal Translator.
- Before: The instructions said, "Jenkins, go to the left shelf and grab the hammer."
- After: The instructions say, "Get the hammer." The Universal Translator figure out whether to ask Jenkins or the new GitHub robot where the hammer is.
- Why it matters: Now, if they want to switch robots again in the future, they only have to update the Translator, not rewrite the entire instruction manual.
2. The "Pre-Packed Lunchbox" (Containerization)
Instead of sending the robot to the hardware store every time it needs a tool, they created a magic lunchbox (a container image).
- Before: The robot arrived at the job site empty-handed, had to find a store, buy a hammer, a screwdriver, and a wrench, then start working.
- After: The lunchbox arrives already packed with every single tool the robot will ever need, perfectly organized. The robot just opens the box and starts working immediately.
- Why it matters: This eliminated the "shopping trip" delay and ensured the tools were always the exact same, high-quality versions.
3. The "One Big Book" (Simplified Structure)
They took the instructions from the four scattered filing cabinets and bound them into one single, clear book.
- Before: You had to know which cabinet held the "password" and which held the "test script."
- After: Everything is in one place. It's much easier for new employees to learn the job.
The Results: A Speed Boost
The changes were dramatic:
- Speed: The job that used to take 12 minutes now takes 2 minutes. That is an 82% reduction in time!
- Reliability: Because the "lunchbox" always has the same tools, the job never fails because of missing parts.
- Security: The tools are pre-checked and sealed in the lunchbox, so no one can sneak in a bad tool.
- Freedom: The system is no longer tied to the old Jenkins robot. It can work on any modern platform.
The Human Element
The paper also highlights that technology isn't everything. The team had to teach the COBOL developers (who were used to the old, slow ways) how to use the new, fast system. They realized that if the new system was too confusing, the developers would reject it. So, they kept the instructions simple and monolithic (one big block) rather than breaking them into tiny, complex pieces, making it easier for people to adopt.
The Takeaway
This story proves that even in the most rigid, regulated, and "old-school" industries (like banking with COBOL), you can modernize your systems. You don't have to tear down the vault to fix the door. By using smart translation layers and pre-packed toolboxes, you can make ancient systems run as fast and securely as modern ones.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.