
WEBINAR
The Cost of Not Modernizing: what we learned (and the recording)

Everyone agrees modernization has to happen. Almost everyone has seen it go badly. On November 18, we sat down with credit union and bank technology leaders to talk about why, together with our partners at Stickley on Security.
Devsu CTO Álvaro López and CEO Felipe Cornejo, with moderator Matt Deaton, our Chief Growth Officer, didn’t spend the session on core replacement or software demos. They looked at a question that gets less attention: why do modernization projects struggle before anyone writes a line of code?
Here are the ideas worth taking back to your team.
The problem usually isn’t the technology
You’ve probably seen this one. The project is approved, the budget is there, the team is ready and the roadmap looks reasonable. Then someone finds out the system is far more connected than anyone realized.
“How many modernization initiatives actually fail because the technology doesn’t work?” Álvaro asked. “Probably fewer than we think.” More often, the institution doesn’t fully understand the system it’s trying to change.
Most of that risk doesn’t sit inside the core. It sits around it:
- Dependencies nobody documented. A low-priority internal app turns out to pull data from three systems, one of them an old batch process feeding a database no one knew about.
- Architecture that drifted. The diagram from five years ago isn’t wrong all at once. It becomes wrong one small change at a time.
- Knowledge in a few heads. Someone knows why a job runs at 2 a.m. every Tuesday, or that restarting one app means restarting another five minutes later. None of it is in the official architecture.
Why does it stay hidden? Because institutions are built to keep systems running, not to understand them. “The better a legacy system survives,” Álvaro said, “the harder it becomes to understand.” Everything works, so nobody takes it apart. Until you decide to change it.
The cost curve is really a discovery curve
Felipe framed it from the leadership side. Projects rarely stall because engineers can’t execute. They stall because the team uncovers uncertainty faster than it can resolve it. Who owns this integration? Why does this service call that API? Is this document still true?
Felipe shared the story of a bank whose core replacement estimate kept climbing year after year, until the project was cancelled and written off. “Nothing about their ability to execute changed between those estimates,” he said. “What changed was what they knew.” (The full story is in the recording, and it’s worth the watch.)
That’s also why adding people rarely fixes it. If nobody has a reliable picture of the architecture, a bigger team just means more people asking the same unanswered questions. Known complexity can be managed. Unknown complexity is what hurts.
Start with visibility, not a roadmap
Álvaro’s main point: modernization shouldn’t start with a roadmap. It should start with understanding. He walked through a loop the team uses:
- Understand. Build an evidence-based picture from source code, infrastructure, logs, pipelines, API definitions and the people who know the history. Each source shows part of it. Code tells you what an app does, telemetry tells you what it’s actually doing, and people tell you why it exists.
- Prioritize. Age is a signal, not a strategy. Weigh technical risk, operating cost, security exposure and business value. Sometimes a fairly new app in the middle of everything carries more risk than the oldest one.
- Execute in small steps. Take one meaningful piece, change it, check the result and learn. A three-year plan carries assumptions you may only find out are wrong in month 12.
- Measure. Fewer incidents, lower infrastructure cost, shorter cycle time, fewer manual processes, more frequent deploys. Without measurable outcomes, modernization turns into an endless technology project.
- Improve and repeat. Each step teaches you something, like a dependency you missed or a process you can drop. That feeds the next decision.
Good visibility isn’t a prettier diagram. It’s being able to answer questions like: if we change this application, what breaks? Which systems depend on this database? Where are we running technology that’s getting hard to support?
Felipe compared it to a balance sheet. Nobody prepares one in Q1 and calls it done. Architecture changes with the business, so your picture of it has to keep up. Until recently, that was too slow and expensive to do more than once every few years. With AI, it no longer has to be.
“Modernization isn’t a project. It’s an engineering capability.” — Álvaro López, CTO, Devsu
From the Q&A: your core modernization questions
Do we need to replace our core? Not as a starting point. The core is deeply connected to everything else, so changing it before you understand those connections adds risk. There’s real value in modernizing around it first: digital channels, data services, pipelines and internal apps. That simplifies integrations and draws cleaner lines around the core. If replacing it still makes sense later, you decide from a position of understanding, not pressure.
Where does AI fit? AI speeds up code analysis, dependency discovery and documentation, and it’s already changing how fast teams can understand old systems. But it accelerates understanding; it doesn’t replace it. You still need to validate what you find, add business and operational context, and have people who can make architecture decisions.
How do we justify modernization to the board? Don’t present it as a technology investment. Frame it as a business decision: what risk you reduce, what operating cost you take out, what you can do next. Then answer the question that matters most: what happens if we don’t? “The cost of modernization is visible. It’s a line item,” Felipe said. “The cost of not modernizing is often hidden. Make it visible.”
Three questions to take back to your team
You can ask these tomorrow, without approving or spending anything:
- Do we actually know what depends on our most critical systems?
- Which modernization decisions are we making on assumptions rather than evidence?
- Are we running modernization as a one-time program, or building the ability to change our technology safely, over and over?
If your team can’t answer them today, that’s normal. Most can’t. It simply tells you where to look first.
Watch the full session
The recording covers all of this in more depth, including the full Q&A.


