Enterprise application modernization is rarely about one system. It is about an application portfolio of dozens or hundreds of systems that share data, users, and release calendars, where the order of work decides whether the program delivers value early or stalls in planning. Choosing a technical path for each application is the easier part. The harder questions are which applications go first, how to group them into waves, who has the authority to change the plan, and how to tell whether a wave worked. This guide answers those questions for CTOs, CIOs, and enterprise architects who plan across a whole portfolio rather than a single app.
Key Takeaways
- Rank the portfolio with a written scorecard before choosing a technical path for any single application.
- Score each application on business criticality, change frequency, support status, dependency fan-out, and security exposure.
- Start with a foundation wave for CI/CD, identity, and observability, then move low-dependency applications that change often.
- Fund one wave at a time, with a stage gate that can stop, reshape, or continue the program.
- Judge each wave by delivery metrics and the share of the portfolio on supported platforms, not by go-live dates alone.
Why Enterprise Programs Stall Before the First Release
Most portfolio programs that stall do so before anything reaches production, and the cause is usually the order of work rather than the technology. Three patterns repeat: the first application chosen is the wrong one, dependencies nobody mapped surface mid-wave, and the organization keeps the team structure that produced the old architecture.
The first pick is often the most visible system, because it already has a sponsor and a budget line. Visible systems tend to be the most connected. The team then spends its first months negotiating interface changes with every consumer instead of shipping. Momentum and sponsor patience run out together.
Hidden dependencies are the second cause. A nightly batch job, a shared database table, or a report that reads another system’s schema directly will not appear in an architecture diagram drawn from memory. When one of them breaks during cutover, the wave pauses until someone traces it.
The third cause is structural. Conway’s Law observes that systems mirror the communication structure of the teams that build them. If a program splits a monolith into services but keeps one central team that approves every change, the new services drift back toward the old coupling. Enterprise modernization therefore changes team boundaries and ownership as well as code.
Standing still has a price too. According to the US Government Accountability Office, federal agencies typically report spending about 80% of their IT budgets on operations and maintenance of existing IT (GAO, GAO-25-107795, 2025). That figure covers the US federal government only. In the private sector, a vendor-funded survey of 500 IT decision makers in the US and UK, at companies with revenue of $500 million or more, found that 49% saw actual legacy maintenance costs exceed their planned costs in the previous year (Ensono, State of IT Modernization, 2025).
How Do Enterprises Prioritize Which Applications to Modernize?
Enterprises prioritize applications by scoring each one against the same small set of criteria, then sequencing by dependency. A practical scorecard covers business criticality, change frequency, support status, dependency fan-out, and security exposure. Applications that change often, run on unsupported platforms, and have few dependents usually move first. Heavily connected core systems move last.
The scorecard turns a debate about opinions into a debate about evidence. It also forces the portfolio assessment to collect the same data for every system, which is where most programs find out how little they knew about their own estate. An application portfolio assessment of this kind is the input to sequencing, not a separate project.
|
Criterion
|
What to measure
|
How it changes the order
|
Data source
|
|
Business criticality
|
Revenue, users, or regulated processes that depend on the app
|
Raises priority, and raises the bar for testing and parallel run
|
Business owners, service catalog
|
|
Change frequency
|
Releases or change requests per quarter
|
Frequent change pays back sooner in time to market
|
Ticketing and deployment history
|
|
Support status
|
Vendor support dates, framework versions, open patches
|
Unsupported platforms move up because risk grows every quarter
|
Vendor notices, software inventory
|
|
Dependency fan-out
|
Number of systems that call the app or read its data
|
Low fan-out moves an app earlier; high fan-out moves it later
|
Network, API, and database access logs
|
|
Security exposure
|
Internet-facing surface, known vulnerabilities, data sensitivity
|
High exposure moves an app up, sometimes into a wave of its own
|
Threat modeling, vulnerability scans
|
Dependency fan-out is the criterion most portfolios guess at. Measure it from logs and database access records rather than interviews, because interviews miss the integrations nobody remembers building.
Support status carries a deadline. Applications on end-of-life platforms collect unpatched issues in unsupported frameworks, and that security risk compounds every quarter they stay in place.
“The signal I trust most is how many systems read an application’s data. Teams usually start with the most visible system because it has a sponsor, then spend the first wave renegotiating interfaces. Start where few systems depend on you.” Quy Truong, Senior Solution Architect at Saigon Technology
Keep the weighting simple. Score each criterion from 1 to 5, agree the weights with business owners once, and resist adding criteria after the first round. Twelve criteria produce ties and arguments, while five produce a ranked list a steering group can act on. Across a large portfolio, a defensible ranking is worth more than a precise one.
Scoring a Sample Portfolio of Five Applications
The example below is illustrative. The five applications are hypothetical and do not describe any client system.
|
Application
|
What the scores show
|
Placement
|
|
Customer portal
|
Changes weekly, few dependents, moderate exposure
|
Wave 1
|
|
Reporting tool built on Excel workbooks
|
Low criticality, frequent change requests, unsupported runtime
|
Wave 1
|
|
Identity and access service
|
Called by every other app, high exposure
|
Foundation wave
|
|
Order management system
|
High criticality, high fan-out, stable release pattern
|
Final wave
|
|
Internal scheduling tool
|
Rarely changes, supported platform, few users
|
Hold, review yearly
|
Read the result as a starting order, not a commitment. The identity service breaks the fan-out rule on purpose: every later wave depends on it, so it is built as a shared platform capability before anything else moves. The scheduling tool scores low on every criterion, which makes it a candidate to leave alone for now.
Sequencing Modernization Waves by Dependency
Modernization waves work best when they follow the dependency graph outward from the platform. Build shared foundations first, then move applications with few dependents and frequent change, then shared services. Leave the most connected core systems for last, when the team has tooling, patterns, and evidence from earlier waves.
A typical enterprise modernization roadmap has four kinds of wave:
- Foundation wave: CI/CD pipelines, an identity platform, observability, infrastructure as code, and automated tests. Nothing customer-facing ships, yet every later wave runs on this tooling.
- Wave 1: low-dependency, high-change applications. These prove the delivery pattern quickly and pay back in time to market, because they are the apps the business asks to change most often.
- Wave 2: shared services. Integration layers, data services, and APIs that several applications call. An API gateway lets old and new consumers coexist while interfaces move.
- Final wave: core systems with high fan-out. Order management, billing, or the main system of record. By now the team has tested patterns and a current dependency map. When planning work on modernizing long-running core systems, allow for a longer cutover.
Each wave needs its own cutover plan. A parallel run, where old and new systems process the same transactions and the results are compared, is the safest cutover for anything that touches money or regulated data. Run test migrations with reconciliation checks and referential integrity tests well before the cutover date.
Where a wave moves data, a separate data track keeps profiling and cleansing data off the critical path. Our approach to data platforms behind modernized apps covers that track. Keep each wave small enough to finish before business priorities shift, because a wave that never ends stops producing the evidence that funds the next one.
Governance and Funding Across a Multi-Year Portfolio
Portfolio programs need explicit decision rights and wave-by-wave funding. Name who owns sequencing, scope, technical standards, and the stop decision, then release money one wave at a time against agreed exit criteria. This keeps the program accountable without locking it into a multi-year plan that is out of date by its second year.
Overruns are common enough to plan for. In a survey of US and UK IT leaders by Ensono, a vendor of IT modernization services, 71% of modernization initiatives had exceeded planned costs (Ensono, State of IT Modernization, 2026). Delay costs money as well: a Savanta survey of more than 500 IT decision makers for Pegasystems estimated that the average global enterprise wastes more than $370 million a year because of technical debt (Pegasystems, 2025).
|
Decision
|
Who owns it
|
Review cadence
|
|
Portfolio sequencing and wave scope
|
Executive steering committee, business and IT leads
|
Each stage gate
|
|
Technical standards and reference architecture
|
Enterprise architecture group
|
Quarterly, or when a wave exposes a gap
|
|
Technical path per application
|
Wave team, with architect sign-off
|
At wave planning
|
|
Funding for the next wave
|
Steering committee and finance
|
Each stage gate
|
|
Stop, pause, or reshape
|
Steering committee, on evidence from wave metrics
|
Each stage gate
|
Decision rights matter more than the org chart. When business owners and IT both believe they own sequencing, every wave plan turns into a negotiation. Write the table down, publish it, and point to it when disputes come up.
Funding per wave takes the place of a single multi-year budget. Each stage gate asks three questions: did the last wave meet its exit criteria, has the scorecard changed, and does the next wave still have a business owner? Money for the next wave is released only when all three answers are clear.
Track total cost of ownership per application alongside the initial investment. Ongoing operating expenses, change management effort, and the shift from fixed hardware cycles to a cost model that matches actual usage are where enterprise modernization budgets are won or lost over time.
What Is Enterprise Application Modernization?
Enterprise application modernization is the coordinated update of many business applications across an organization, planned as one program with shared governance, shared platforms, and a sequenced roadmap. It differs from modernizing a single app in scale: decisions about order, funding, and shared services affect every system at once, so they are made at portfolio level.
Each individual application still needs its own technical path, from infrastructure changes to new code. That per-app choice is covered in our guide to choosing a modernization approach per application. This guide sits one level above it, at the order, the waves, and the governance that make those per-app choices add up to a working portfolio.
How Generative AI Speeds Up Legacy Code Analysis
Generative AI speeds up legacy code analysis by summarizing large codebases quickly, then drafting documentation, dependency summaries, and tests that describe current behavior. It shortens the discovery phase of each wave. It does not remove the need for engineers who understand the system, because every AI output still needs review before anyone acts on it.
Where it helps most:
- Reading undocumented code. A model can summarize what a module does, which tables it touches, and which modules it calls, giving engineers a first draft of the dependency map.
- Drafting documentation. Plain-language descriptions of business rules let business owners confirm behavior before anything changes.
- Writing characterization tests. These tests record what the system does today, quirks included, so the team can show that the modernized version behaves the same way.
- Translating between languages or frameworks, as a draft for engineers to check rather than finished code.
Models also have limits. They miss behavior that lives outside the code, such as configuration files, scheduled jobs, and database triggers. They can describe logic confidently and wrongly. The working rule is simple: AI drafts, engineers decide, and every AI-drafted test, summary, or code change goes through human review before it is trusted.
Used this way, AI shortens discovery without lowering engineering accountability. Teams planning AI-assisted modernization should budget reviewer time into every wave rather than treating it as overhead.
Measuring Progress After Each Wave
Measure each wave with delivery metrics that show whether the modernized applications are easier to change and run, plus one portfolio metric that shows how much of the estate has moved. Go-live dates show activity. These metrics show whether the program is improving the business’s ability to ship and recover.
|
Metric
|
What it tells you
|
When to check
|
|
Deployment frequency
|
Whether teams release modernized apps more often
|
Monthly, from the first wave
|
|
Lead time for changes
|
How long a committed change takes to reach production
|
Monthly
|
|
Change failure rate
|
Share of releases that cause an incident or rollback
|
Monthly
|
|
Time to restore
|
How quickly service recovers after a failure
|
After each incident, reviewed monthly
|
|
Share of portfolio on supported platforms
|
How much end-of-life risk remains
|
Each stage gate
|
The first four are the original “four keys” delivery metrics from the DORA research program. Set a baseline for each application before its wave starts, otherwise there is nothing to compare against. Add operational measures where the business cares about them, such as response time, throughput, and latency, uptime percentage, or customer satisfaction scores for customer-facing systems.
The last row, portfolio coverage, is the number a steering group reads first. It answers the question that funds the next wave: how much risk is left?
When an Outside Engineering Team Helps
An outside team helps when the program needs skills or capacity the in-house team cannot supply without stopping other work. Two signals are common. Nobody left on staff can read the older stack with confidence, or the business needs new features while the old system is still being modernized, which means two teams running at once.
A partner adds the most after the scorecard and wave plan exist, so the outside team inherits a clear order of work instead of setting it. Saigon Technology works as a modernization partner for enterprise portfolios, joining at wave level with engineers who can read the older stack and build the new one.
FAQs
How many applications belong in the first modernization wave?
Fewer than most plans assume. A first wave should hold enough applications to prove the delivery pattern and the foundation tooling, usually a handful of low-dependency systems that change often. Its job is to produce evidence for the next funding decision, so finishing it matters more than its size.
Should you modernize the riskiest application first?
Usually not, unless the risk is a security exposure or an end-of-life platform that cannot wait. Starting with the most connected or most critical system means learning the delivery pattern where there is the least room for error. Start with lower-risk systems, and move core systems once the team and the tooling are proven.
Who should own modernization decisions, IT or the business?
Both, with the split written down. The business owns priorities and the stop decision, because it carries the outcome. IT owns technical standards and the path for each application. A joint steering committee that meets at each stage gate settles conflicts between the two.
Can teams keep shipping features during a modernization program?
Yes, if the plan allows for it. Teams can keep shipping on applications outside the current wave, and routing through an API gateway lets new features land on modernized components while older ones keep running. A full feature freeze across a multi-year program rarely survives contact with the business.
When should you stop modernizing an application?
Stop when the next increment costs more than the risk or value it addresses, or when the business plans to switch the application off. Set a stop rule at each stage gate: if an application’s scores fall below the line for the current wave, move it to hold and spend the budget on the next wave instead.