The short version
The legacy skills shortage is structural. The average COBOL developer is close to 60, a large share of that workforce retires within the decade, and few new people are learning the languages. Meanwhile the systems aren’t going anywhere, so demand keeps climbing while supply falls.
You have four responses: hire and retain specialists, rent them through managed services, use Gen AI to capture knowledge and assist the staff you have, or modernize the code so it can be maintained by a larger talent pool. The first three manage the problem. Only the fourth makes it smaller.
The durable plan does two things at once: capture the institutional knowledge with Gen AI before it walks out the door, and reduce the dependence by converting the code deterministically to a modern language. That’s the model behind DMS, the engine Modernize Software is built on.
The shortage is structural, not a blip
This problem has a demographic shape, which is what makes it predictable and serious. The workforce that knows these systems is aging out, and the pipeline behind it never refilled.
- ~60 the average age of a working COBOL developer, with many surveys placing the median right around there.
- ~75% of the existing COBOL developer workforce is expected to retire within the next 10 to 15 years.
- ~70% of universities no longer teach COBOL, so the pipeline of new entrants has largely dried up.
- 5 to 10 years the window in which the mainframe skills shortage is projected to reach critical severity.
At the same time, the systems these people maintain are central, not peripheral. Widely cited estimates put the installed base at around 240 billion lines of COBOL still in production, processing on the order of trillions of dollars in transactions every day, with mainframes still handling a large majority of business transaction volume. Demand for the skill is rising while the people who hold it are leaving. That’s the squeeze, and it tightens every year.
It also reaches past COBOL. PL/I, Assembler, RPG, Natural, and JOVIAL all sit in the same bind, and the broader IT skills gap spans security and data work too. The legacy languages are the sharpest version of it because the pool is smallest and the systems are the most critical.
What the shortage actually costs you
The cost shows up in three places: the price of the people, the speed of getting anything done, and the risk of something breaking that nobody left can fix.
The price of scarce skills keeps climbing
When supply falls and demand rises, the price moves. Mainframe COBOL roles now commonly pay well into six figures, with experienced developers in the range of $120,000 to $200,000 or more, and independent consultants commanding roughly $125 to $200 an hour. Hiring is slow on top of being expensive: bringing on a capable COBOL developer commonly takes 90 to 180 days, and that’s before the months of ramp-up on an unfamiliar, undocumented system. Industry surveys find that around 91 percent of organizations expect to hire mainframe talent within two years, which tells you how many buyers are chasing the same shrinking pool.
The drag on everything you want to ship
The shortage doesn’t just raise costs. It slows the business. In one set of industry surveys, 93 percent of organizations said acquiring the right mainframe resources is moderately to extremely challenging, 96 percent reported significant development and testing bottlenecks on the platform, and 79 percent named staffing limits and weak tooling as the main barriers to meeting their goals. IBM has found that a majority of executives now consider Gen AI on the mainframe critical, which is a sign of how much the skills bottleneck is holding back the work that depends on these systems.
The operational risk of a single point of failure
This is the part that turns a staffing issue into a board-level one. When a handful of aging experts are the only people who understand a critical system, that system is one retirement or one illness away from being unmaintainable. It isn’t hypothetical. During the COVID-19 surge, several states found their COBOL-based unemployment platforms buckling under load, and governors publicly appealed for retired COBOL programmers to come back and help. The wider picture is just as stark: IDC has projected on the order of 5.5 trillion dollars in losses tied to IT skills shortages in 2026, having trimmed an earlier estimate by about a trillion thanks to Gen AI coding tools and better training.
The hidden cost: knowledge walks out the door
The salaries and the hiring delays are visible. The most expensive loss usually isn’t. When a senior developer retires, decades of undocumented decisions leave with them: why a routine handles a date the way it does, which edge case a strange branch exists to catch, what a cryptic flag actually controls. The industry calls it tribal knowledge, and most of it was never written down.
Surveys bear this out. A large share of distributed-systems developers admit they have little understanding of the mainframe, and a similar share of organizations worry that a lack of documentation is itself a source of risk. The legacy code encodes the real business rules of the company, and the only complete copy of how those rules work often lives in the heads of people who are about to leave. Lose them before you capture it, and you’ve lost the specification for your own business.
Why this changes the order of operations: knowledge capture is time-sensitive in a way that hiring and modernization aren’t. You can hire next year and modernize over two years, and the experts who can explain the system are leaving now. Capturing what they know comes first, while they’re still here to confirm it.
Why hiring your way out doesn’t work on its own
The instinct is to hire more legacy developers. It’s a reasonable short-term move, and it can’t be the whole plan, because the math runs the wrong way. The pool is shrinking faster than open roles can be filled, and the training programs that exist can’t keep pace with the retirement cliff. New graduates mostly don’t want these roles, seeing them as a detour away from current technology. Even when you do hire a junior and train them, getting productive on a large, undocumented legacy system takes many months. And every organization in this position is bidding for the same people, which keeps pushing the price up.
So hiring and retention matter, and they buy time. What they don’t do is change the underlying exposure. After a successful hiring round, you still have a critical system that only a small, aging group can maintain, and you’ve paid a premium to stay exactly that exposed. To actually reduce the risk, you have to reduce how much scarce skill the business depends on.
The four responses, compared honestly
There are four legitimate ways to respond, and most organizations end up using more than one. The question is which of them reduces the dependence rather than just managing it.
1. Hire and retain specialists
Recruit legacy developers and work hard to keep the ones you have. This adds capacity directly and keeps the lights on. It’s slow and expensive, it doesn’t scale as the pool shrinks, and it leaves the single-point-of-failure risk in place. Useful, and not a strategy by itself.
2. Outsource to managed services or staff augmentation
Bring in a managed-service provider or contractors who keep a pool of legacy specialists. This gives you fast access to expertise without running the recruiting yourself, and it’s a sensible stopgap for stabilizing a system. It rents the same scarce skill rather than reducing your need for it, and the cost tends to rise as the talent gets rarer.
3. Capture knowledge and assist your people with Gen AI
Use Gen AI to document the systems, explain unfamiliar code, and extract the business rules buried in the legacy source into plain language. Tools across the industry now do exactly this: generating technical and functional documentation, surfacing program logic and data flows, and answering questions about the codebase so a newer engineer can get useful faster. This is high-value work. It preserves the knowledge that’s about to retire, speeds onboarding, and makes the people you have more effective. On its own it doesn’t move the system off the scarce language, so it’s a powerful complement to modernization rather than a replacement for it.
4. Modernize the code to reduce the dependence
Convert the system to a modern language that a much larger talent pool can maintain, or restructure the legacy code in place so it’s no longer the preserve of a few specialists. This is the only response that shrinks the problem instead of managing it. Done well, the system that used to need a rare COBOL expert becomes a system a mainstream developer can read and change. The catch is that the conversion has to preserve behavior exactly, which is why how you modernize matters as much as whether you do.
The durable answer: shrink the dependency and capture the knowledge
The two responses that last are the ones that work together. Capture the knowledge while the experts are still here, and reduce the dependence by modernizing the code they’re the only ones who understand. One preserves what you have. The other means you’ll need less of it.
This is where deterministic transformation earns its place. Modernize Software is built on DMS, which uses symbolic AI and enhanced compiler technology to convert legacy code to a modern language deterministically, with output built to be functionally equivalent to the original. The same construct converts the same way across the whole system, so a 5,000,000-line program becomes a coherent modern codebase rather than a pile of inconsistent translations. Gen AI augments the work by capturing the institutional knowledge as the conversion proceeds: documenting the system, explaining the original code, and extracting the business rules so they’re recorded in plain language instead of trapped in someone’s memory.
There’s an honest nuance worth stating. Modernizing a legacy system still takes some legacy expertise to do right, so this doesn’t make the skills question vanish overnight. What it does is change the trajectory. Automated transformation needs far less scarce expertise per line than a hand rewrite, it captures the knowledge as it goes, and when it’s finished the system no longer depends on a shrinking pool at all. You spend a bounded amount of the rare skill now to stop needing it indefinitely.
The principle: every other response is a recurring cost that grows as the talent gets rarer. Reducing the dependence is a one-time investment that ends the recurring cost. The sooner you start, the more of the institutional knowledge you can still capture from the people who hold it.
A practical plan for the next 24 months
You don’t have to choose one response and abandon the rest. Sequence them so the time-sensitive work happens first and the durable work follows.
- Inventory and triage by risk. Map which systems depend on the fewest and oldest people, and which carry the most business risk if they fail. That intersection is where you start.
- Capture the knowledge now. While the experts are still in their seats, use Gen AI to generate documentation and extract business rules, and have those experts confirm the output. This is the step that can’t wait.
- Stabilize the highest-risk systems. Use retention and, where needed, managed services to keep the critical systems safe in the short term, so you’re modernizing from a stable base rather than firefighting.
- Modernize to reduce the dependence. Convert the systems that matter most to a modern language deterministically, validated for functional equivalence against the original, so the new code is something a broader team can own.
- Phase it, don’t big-bang it. Move functionality across incrementally using a pattern like the Strangler Fig, rather than attempting a single risky cutover. Each phase lowers your exposure a little further.
Common mistakes, and how to avoid them
- Waiting for the cliff. The shortage is predictable, so treating it as a future problem is the costliest mistake. The expertise you need to do this well is leaving on a known schedule.
- Treating it as a pure staffing problem. Hiring and contracting keep the lights on, and they leave you just as dependent. Pair them with work that reduces the dependence.
- Losing the knowledge before capturing it. Once a senior expert retires without their knowledge being written down, the cost of recovering it from the code alone is far higher. Capture first.
- Converting with Gen AI alone. Gen AI is excellent at capturing knowledge and explaining code, and its output is probabilistic, so it can’t guarantee the converted system behaves like the original. Use deterministic transformation for the conversion and Gen AI for the knowledge work around it.
- Attempting a big-bang rewrite to escape. A panic rewrite is the highest-risk path of all, and it’s where budgets and timelines most often collapse. Convert deterministically and phase the rollout.
Where Modernize Software fits
Modernize Software is built on DMS, which uses symbolic AI and enhanced compiler technology to convert legacy code deterministically, with Gen AI capturing the documentation and business rules along the way. That combination addresses the talent shortage from both directions at once: it preserves the institutional knowledge that’s about to retire, and it moves your critical systems onto a modern language that a far larger pool of developers can maintain. The systems that used to be a single-point-of-failure risk become systems your existing team can own. If you’re staring at a retirement cliff on a system you can’t afford to lose, that’s the conversation to have, and it’s better had while the experts are still here to help.
Talk to Modernize Software
Tell us which systems keep you up at night and who the few people are who understand them, and we’ll map a plan to capture what they know and reduce what you depend on them for.
Frequently asked questions
How bad is the COBOL and legacy developer shortage really?
It’s structural. The average COBOL developer is close to 60, a large share of that workforce retires within the decade, and most universities stopped teaching the language, so few new people are entering. The systems aren’t going away, with widely cited estimates of around 240 billion lines of COBOL still in production. Demand keeps rising while supply falls, and the shortage is projected to reach critical severity within 5 to 10 years.
Why can’t we just hire and train more legacy programmers?
You can, and it helps in the short term, and it can’t keep pace with the math. The pool shrinks faster than roles get filled, training can’t match the retirement cliff, new graduates mostly avoid these roles, and ramping up on a large undocumented system takes months. Every organization in this position is also bidding for the same people, which drives the price up. Hiring buys time; it doesn’t reduce how dependent you are.
What’s the real cost of the shortage beyond salaries?
Three things. Rising pay and slow hiring, with capable developers commonly taking 90 to 180 days to find. A drag on delivery, with most organizations reporting development and testing bottlenecks tied to the skills gap. And operational risk, because a system only a few aging experts understand is one retirement away from being unmaintainable, as the pandemic-era failures of some COBOL unemployment systems showed.
Can Gen AI solve the legacy skills shortage?
Gen AI helps a lot with part of it. It documents systems, explains unfamiliar code, and extracts business rules into plain language, which preserves knowledge and makes current staff more effective. It’s probabilistic, so it can’t guarantee that converted code behaves like the original, which means it shouldn’t own the conversion itself. The strongest approach pairs Gen AI for knowledge capture with deterministic transformation for the conversion.
What should we do first if our experts are about to retire?
Capture their knowledge now, because that’s the time-sensitive step. Use Gen AI to generate documentation and extract business rules while the experts can still confirm the output. In parallel, triage your systems by risk, stabilize the most critical ones, and plan a deterministic modernization of the systems that matter most so you stop depending on a shrinking pool.
Does modernizing eliminate the need for legacy skills?
It reduces it sharply rather than removing it instantly. Modernizing well still needs some legacy expertise, and automated transformation needs far less of it per line than a hand rewrite, and it captures the knowledge as it goes. When the conversion is complete, the system runs in a modern language a broad pool of developers can maintain, so the long-term dependence on rare skills ends.
Sources and further reading
Selected references behind the figures in this guide.
- The COBOL job market in 2026: developer age, retirement share, demand and salaries. https://datafield.dev/blog/cobol-job-market-2026.html
- Learning COBOL and mainframe systems in 2025: average age, university coverage, and the 5 to 10 year shortage window. https://www.softwareseni.com/learning-cobol-and-mainframe-systems-in-2025-legacy-technology-career-paths-and-opportunities/
- COBOL demographic data: average age, retirement rate, and the installed base and transaction figures. https://lists.openmainframeproject.org/g/wg-cobol/attachment/113/1/systemsjournalcobolsept172020.pdf
- COBOL developer shortage as a modernization problem, including the pandemic-era system failures. https://softwaremodernizationservices.com/insights/cobol-developer-shortage-solutions/
- Missing mainframe and IT skills: the IDC skills-loss projection and hiring-intent survey data. https://planetmainframe.com/2026/01/missing-mainframe-and-it-skills-how-enterprises-can-respond/
- The mainframe skills gap and the resourcing, bottleneck, and Gen AI survey figures. https://cptglobal.com/resources/cpt-insights/why-the-mainframe-skills-gap-is-the-blind-spot-in-ais-future
- Tribal knowledge loss and Gen AI knowledge capture on the mainframe. https://www.bmc.com/blogs/genai-introducing-bmc-ami-assistant/
- Gen AI for documentation and business logic extraction in mainframe modernization. https://aws.amazon.com/blogs/migration-and-modernization/accelerate-your-mainframe-modernization-journey-using-ai-agents-with-aws-transform/
- Hiring timelines and the cost of finding COBOL talent. https://www.integrativesystems.com/cobol-programmers/
- DMS Software Reengineering Toolkit, technical overview. https://en.wikipedia.org/wiki/DMS_Software_Reengineering_Toolkit
.png)
info@semanticdesigns.com
