Legacy modernization company: senior teams that modernize in steps
Senior engineering teams that modernize legacy applications in steps: tests around old behavior, strangler-fig replacement, re-platforming and refactoring, with the system running throughout.
By the Ryz Labs team · Updated October 2026
Ryz Labs is a legacy modernization company whose senior engineering teams move aging applications onto modern platforms one piece at a time: they wrap old behavior in tests, re-platform to current runtimes and the cloud, refactor monoliths, and replace components behind a strangler-fig facade while the business keeps running. That includes taking companies off the mainframe with API-first rebuilds, often in Python. Our engineers come from the top 1% of the tens of thousands we interview and work on US business hours.
What we build
- Modernization assessment: a map of modules, dependencies, data flows, test coverage and change frequency, with a recommendation per component: retain, re-platform, refactor, replace or retire.
- Characterization tests: tests that record what the legacy system actually does today, including its quirks, so changes can be verified against real behavior before anything is rewritten.
- Strangler-fig migrations: an API gateway or routing layer in front of the old application, with new services taking over one route or capability at a time until the old code can be switched off.
- Runtime and framework upgrades: .NET Framework to .NET 8+, Java 8 and Java EE to Java 21 and Spring Boot 3, AngularJS to Angular or React, PHP 5 to PHP 8, Python 2 to 3.
- Re-platforming: moving applications from on-premises servers or WebLogic and WebSphere to containers on ECS, EKS, AKS or Azure App Service, with the code changes needed to run there.
- Monolith decomposition: modular monolith first, with clear module boundaries, then extracting services only where independent scaling or team ownership justifies it.
- Database modernization: moving logic out of stored procedures, migrating from Oracle or DB2 to PostgreSQL or SQL Server, and splitting shared schemas safely.
- Mainframe exits: CICS transactions, batch jobs and copybook data rebuilt as API-first services, often in Python, proven against mainframe output before each cutover. See mainframe modernization services, or hire mainframe developers for your own team.
- Integration replacement: replacing file drops, FTP batch jobs and point-to-point SOAP calls with APIs and events, often starting with API development around the old core.
How an engagement works
Talk. We learn why modernization is on the table now (end-of-support runtimes, security findings, release speed or hosting cost), where incidents cluster, and what can't go down during a cutover. Then we send a written plan for the first slice, its cost and the names of the people who would do it.
Match. We propose engineers who read the old stack and build in the new one, such as Java EE and Spring Boot, or Web Forms and ASP.NET Core.
Join. The team works in your repos, CI and environments, pairs with the engineers who hold the system knowledge, and joins your standups and release process.
Grow. Add engineers as more components move, bring in cloud or data engineers for later phases, or hand the modernized system to your team.
In week 1, the team typically gets the system building locally, reads the code paths with the most change and incidents, and interviews the people who support it. By month 1, characterization tests cover the first slice, CI runs on every change, and the first component has a cutover and rollback plan. By month 3, the usual picture is the first slice in production on the new platform, the routing layer in place, and a sequenced plan for the rest.
The stack our teams work in
| Layer | Tools we use | Notes |
|---|
| Source stacks | Java EE, .NET Framework, Web Forms, classic ASP, VB6, PHP 5, AngularJS, COBOL interfaces | We read the old code before proposing the new. |
| Target stacks | Java 21 and Spring Boot, .NET 8+, Node.js and TypeScript, Python, React, Angular | Usually your team's current standard. |
| Upgrade tooling | OpenRewrite, .NET Upgrade Assistant, Rector (PHP), jdeps, try-convert | Automated recipes for mechanical changes, humans for the rest. |
| Routing and facades | NGINX, Kong, YARP, AWS API Gateway, Azure API Management | The strangler-fig layer between old and new. |
| Testing | JUnit, xUnit, pytest, Playwright, Pact, ApprovalTests | Approval tests capture legacy output as the baseline. |
| Data migration | Flyway, Liquibase, AWS DMS, AWS SCT, Debezium, ora2pg | Change data capture keeps old and new data in sync. |
| Platform | Docker, Kubernetes, ECS, App Service, Terraform, GitHub Actions, Azure DevOps | Modern delivery from the first migrated slice. |
How we modernize without breaking the business
The classic failure is the big-bang rewrite: the team rebuilds from documents, the old system keeps changing, and the cutover reveals behavior nobody wrote down. Senior engineers avoid that path and the quieter failures too:
- Incremental by default. Each slice goes to production on its own and delivers value, so the program can pause or change direction without stranding work.
- Behavior captured before change. Characterization and approval tests record current outputs, including rounding rules, date handling and error codes, so "same behavior" is verified, not assumed.
- Parallel runs and shadow traffic. New components process real requests alongside the old ones and results are compared before traffic switches, which is how hidden business rules surface.
- Feature flags and routing for rollback. Every cutover can be reversed by changing a route or flag, not by redeploying the old system from memory.
- Data consistency planned. Shared databases are the hardest part of decomposition. Change data capture, the expand-and-contract pattern and clear table ownership keep two systems from writing the same data.
- Knowledge transfer. Engineers pair with the people who support the legacy system and record what they learn as runbooks and decision records.
- Security debt paid as you go. Unsupported runtimes, outdated libraries with known CVEs and hard-coded credentials are fixed in each slice rather than left for a later phase.
- Retirement as a goal. The plan includes switching off old components, licenses and servers.
When the bulk of the work is high-volume code translation, AI legacy modernization adds LLM-based conversion with human review on top of the same practices.
What a legacy modernization company should deliver
Whoever you hire, hold them to these deliverables. They are what separates a modernization program from an expensive rewrite:
- A component-level assessment with a retain, re-platform, refactor, replace or retire call for each part, not one verdict for the whole estate.
- Tests that capture current behavior before any code changes, so "it works the same" can be checked.
- Working software early. The first slice should reach production within the first phase, behind a routing layer you can roll back.
- A data plan covering shared tables, sync during the transition and who owns each table afterward.
- Retirement dates for old servers, licenses and, where relevant, mainframe workloads.
- Your team able to run it. Code, runbooks and decision records in your repos, with your engineers paired in throughout.
Our guide to legacy modernization companies compares providers against this list.
Team shapes and cost
Typical Ryz cost is $7,000 to $15,000 per engineer per month. Mid-level engineers are $7,000 to $10,000, senior engineers are $10,000 to $15,000, and leads are $15,000 or more, quoted per team.
- Assessment and first-slice team: a tech lead ($15,000+) plus 2 senior engineers ($20,000 to $30,000) = from $35,000 per month.
- Modernization team: a tech lead plus 4 senior engineers and a senior DevOps engineer: $15,000+ plus 5 × $10,000 to $15,000 = from $65,000 per month. Fits a multi-module strangler-fig program.
- Upgrade pair: 2 senior engineers × $10,000 to $15,000 = $20,000 to $30,000 per month. Fits a contained runtime upgrade such as .NET Framework to .NET 8.
Project cost is team size × duration × monthly rate. Every quote is scoped per team, and you get a plan, a price and the names of the people before you start.
Dedicated team or staff augmentation?
A dedicated development team fits most modernization programs, because sequencing, testing and cutovers need one team that owns the outcome. If your engineers lead the program and need senior capacity, staff augmentation adds engineers who join your sprints and report to your leads. See our hire Java developers and hire .NET developers pages for profiles. When the move also changes hosting, our cloud migration teams run that part.
When Ryz isn't the right fit
If you want to replace the system with a commercial package and only need configuration, the vendor or its implementation partner fits better. If modernization is part of a board-level transformation program with organizational change management, a large consultancy should lead. If your team works on European or Asian hours, a global network will give you better overlap. Our engineers work US business hours, so cutover rehearsals happen during your working day.
Related
FAQ
Should we rewrite or refactor our legacy application?
Rarely a full rewrite. Strangler-fig replacement keeps the system running, delivers value early and exposes hidden behavior one slice at a time. A rewrite can suit small, well-understood systems with good test coverage.
How much does a legacy modernization company cost?
Cost is team size × duration × monthly rate. Typical Ryz rates are $7,000 to $15,000 per engineer per month, and a lead plus two senior engineers starts at $35,000 per month. Duration depends on system size and how many slices you modernize.
How fast can modernization work start?
After the scoping call we propose a team with names. Most of the timeline depends on scope and on your onboarding, especially access to source code, environments and the people who know the system.
How is this different from AI legacy modernization?
This service is engineering-led: architecture, tests, re-platforming and refactoring. AI legacy modernization adds LLM-assisted code translation with human review, which helps most with large volumes of similar code.
Do you modernize mainframe applications?
Yes. Ryz teams take companies off mainframes by rebuilding business functions as API-first services, often in Python, behind the same interfaces, and running old and new side by side until outputs match.
Can you work on systems with no documentation or tests?
Yes, that is the usual starting point. Teams build characterization tests and documentation as they go.
Questions we didn't answer? Email info@ryzlabs.com.