Roundtable recap: AI-driven modernization lessons from cross-industry technology leaders

The roundtable began with a simple question: what’s getting in the way of modernization? The answers differed in detail but not in theme.

• A global logistics leader described customer-facing applications whose delivery timelines no longer met expectations.
• A public transit leader talked about modernizing government systems while also managing one of the country’s largest infrastructure expansion projects—too much work and too little time.
• A banking technology leader described accumulated API debt that needed to be addressed without destabilizing critical operations.

These systems weren’t necessarily failing. They were still supporting the business, but they were creating friction around everything else, including delivery, integration, engineering capacity, and the ability to respond when priorities changed.

The broader data reflects that pressure:

• 70% of enterprise workloads still run on outdated systems, constraining capacity and creativity for everything the organization wants to do next.
• IT teams can spend up to 25 hours every week patching and maintaining them, creating opportunity costs around improving customer experience, developing new products, and other ways to move the business forward.
• 60% of senior developers are considering leaving because of unmaintainable legacy code.

During a live demonstration, leaders walked through the migration of a massive Java and SQL Server application (roughly 500 screens, 8,000 database tables, and no existing documentation) into a modern Angular and Java API architecture using autonomous agents.

These weren’t AI tools accelerating human engineers. They were autonomous workflows running overnight, producing and validating code without a person in the loop.

The results were significant. Compared to traditional approaches, the effort required was traditionally lower:

• A project that might have previously required 50 –100 engineers shrank to a team of 15, trending toward < 10.
•  Estimates showed a 10x improvement in cost efficiency, representing a 90% reduction in costs. 
• While the dollar amount spent on AI model tokens (the computational cost of running these workflows) looked significant in isolation, in context, AI tokens represented < 1% of the total project cost.

What makes this possible is a multi-agent validation approach:

1. One set of agents produces code and specifications.
2. A separate set of agents, operating with different objectives and context, reviews and validates those outputs.

Because the two sets don’t share the same blind spots, error rates drop significantly. Think of it as pair programming applied at machine scale. Just as you wouldn’t ask a developer to test their own code, the same logic applies to AI agents.

A second quality layer, automated equivalence testing, uses tools like Playwright to compare the behavior of the legacy system and the modernized one, screen by screen, across a range of input conditions. During the live demo, the testing caught a filter bug in real time, without human involvement, and flagged it for remediation. The room noticed.

The important nuance is that this approach combines generative AI with deterministic validation.

Speed without certainty doesn’t close the loop. Speed must be coupled with accuracy and trust.

Here’s something the roundtable surfaced with surprising consistency:

Technical capabilities have arrived. Generating and validating code at scale isn't a challenge anymore. The friction has shifted elsewhere because AI can’t discover what it doesn’t know.

Subject matter experts, the people who understand how legacy applications behave in edge cases, with specific user types, under specific conditions are essential participants, not optional stakeholders.

During the roundtable discussion and demonstration, one leader recalled a team member who surfaced a critical detail in their modernization journey: in their slice, external user accounts caused certain screens to behave differently from internal ones. Without that input, an entire category of functionality would have gone undocumented. No AI workflow would have found it on its own.

User acceptance testing (UAT) still runs at a human pace, so when AI can produce testable code in days vs. months, that speed creates a mismatch with organizational processes built for much longer development cycles. Organizations aren't bottlenecked waiting for code to be ready. Instead, the friction point is finding time to test it. That’s a process and people problem, not a technology problem—and it requires deliberate planning before the work starts.

New roles are emerging alongside new tools:

• Product teams that once handed requirements to engineering via Jira tickets are now being embedded directly in development squads, answering agent questions in real time. 
• A new hybrid capability, sometimes called a forward-deployed expert (FDE), sits at the intersection of product thinking and AI tooling, able to prototype rapidly and reduce the cycle from business insight to working software. 
• Specs live in documents stored in repositories alongside code, not tickets in a backlog.

This is what it looks like to modernize your ways of working, not just your codebase.

Along the way, your teams learn and earn trust incrementally, and as one practitioner framed it, “You move at the speed of trust.”

For all the technical discussion, the roundtable kept returning to a straightforward starting point: you've got to prove it before you scale it, so start smaller than you think you should.

What's the recommended starting point for complex modernization?

Start with a vertical-slice proof of value—an engagement that takes one end-to-end slice of an application (from the front end through to the database) through the full modernization process, captures real metrics, and uses those measurements to extrapolate what a complete program would actually cost and take.

This vertical-slice approach replaces guesswork with evidence, and is a much more successful approach compared to "big bang" or multiyear, multimillion-dollar commitments.

One leader described a moment that changed the dynamic on a previous modernization effort:

Their team returned a rebuilt prototype to business users on the second day of an engagement. Those users had been waiting months for equivalent capabilities before.

Seeing real velocity, not a roadmap or a promise is often what converts skepticism into modernization momentum. It takes the conversation with stakeholders, including Board members, from “What might be possible?” to “Let’s talk about what the evidence shows and what to do next.”

Starting with a small, contained scope; a single module; a vertical slice of one application is how you build the organizational credibility that makes it possible to go bigger later. Teams that see AI-assisted modernization deliver on something small become advocates. They carry the message across the organization in ways that a slide deck never will.

Starting small also creates something valuable that no amount of planning can substitute for: it creates a factory model. Teams take one slice, learn from it, apply that learning to the next slice, and move faster with each cycle. It's an effective risk management strategy—and the modernization effort becomes self-improving as it progresses. When you capture the actual effort, cost, speed, and results, you can use those metrics to estimate—and win budget for—what a broader modernization program would really require.

The leaders representing all of the organizations in that room were at different stages. Some exploring, some already mid-journey, some wrestling with how to scale what they’d started.

What they had in common was the recognition that the status quo carries its own cost, and that it's the time for action. 77% of companies are already investing in modernization, in part because the benefit of proven AI-powered modernization approaches didn’t exist two years ago.

If your applications are slowing your business down or quietly blocking your AI initiatives from ever graduating beyond the pilot stage:

1. Take one slice of one application.
2. Measure what AI-driven modernization actually delivers.
3. Build from there. 

The data gained from that experiment will tell you more than any estimate ever could.