09
Consulting
Software Architecture & Technical Consulting
Independent architecture and code reviews, technical due diligence and design advice, so big technical decisions rest on evidence, not habit.
From$2,200
Software Development · Service 06
Legacy Software Modernization
Make aging software safe to change again: an honest assessment, tests around what works, then upgrades or staged replacement with no big-bang cutover.
Starting from
$2,900
- Discipline
- Software Development
- Shortest timeline
- 2 to 3 weeks
- Clients
- Businesses, organizations & founders
- Delivery
- Remote, worldwide
What this service is
A system that has run your business for years has earned some respect. It becomes a liability the day nobody can change it safely, patch it or explain what it does.
Legacy modernization is the work of making an aging system safe to change again. It might be a VB6 or Delphi desktop application, a Microsoft Access database that grew into a business system, a PHP site from before modern frameworks, or a .NET Framework application on a server that no longer receives security updates. The software usually still does its job. What's missing is a supported platform underneath it, tests around it and people who understand it.
We start with an assessment, not a rewrite. Rewriting from scratch is slow and expensive, and it tends to lose the small rules the old system enforces without anyone remembering why. The better route is often to pin down current behavior with tests, upgrade the platform, and replace the risky parts one at a time while everything keeps running. Sometimes the honest answer is to leave the system alone and fix the two things that actually hurt, and we'll say so.
Problems we solve
The situations that bring people to us
Old software rarely fails in one dramatic moment. It gets harder to live with, one workaround at a time. Here's what that tends to look like.
The situation todayWhat changes
Only one person understands the system, and they're retiring, moving on or already gone
Recovered documentation and code that any competent developer can pick up
Small changes take weeks because every fix seems to break something else
Characterization tests that catch regressions before your users do
It runs on an operating system, database or framework that no longer gets security patches
A supported platform with current patches and a schedule that keeps it that way
It depends on third-party components whose vendors disappeared years ago
Modern replacements swapped in one at a time, each one tested
It lives on one office PC or an old server, with backups nobody has tested
Hosting you can monitor, back up and restore, on-premises or in the cloud
You need an API, mobile access or a new integration, and the old code can't offer one
A clean interface around the old core, so new features can grow beside it
What you get
Deliverables
Not every engagement includes every item. Your proposal lists exactly what's in scope, and what isn't.
-
01
Modernization assessment
A written review of the code, data, dependencies and hosting, with a recommendation for each part (leave it alone, refactor, re-platform or replace in stages) and what each option costs.
-
02
Characterization test suite
Automated tests that record what the system does today, quirks included, so every later change is checked against real behavior rather than memory.
-
03
Recovered documentation
Architecture diagrams, a data dictionary, business rules traced out of the code, and the build and deployment steps that used to live in one person's head.
-
04
Framework and dependency upgrades
Moves to supported versions of the language, runtime and libraries in measured steps, such as .NET Framework to current .NET, or an old PHP release to a supported one.
-
05
Security remediation
Known vulnerabilities patched, hard-coded passwords removed, injection risks closed, and access control and logging added where they were missing.
-
06
Incremental replacement
New components built alongside the old system behind a routing layer (the strangler-fig approach), each taking over one function until the old part can be switched off.
-
07
Data migration and cleanup
Records moved out of Access, old SQL Server versions or flat files into a current database, with encoding problems, duplicates and orphaned rows resolved and counts checked on both sides.
-
08
Cutover and rollback plan
Each switchover rehearsed on a copy first, run in parallel where the stakes justify it, timed around your busy periods, and backed by a tested route back.
Visual model
How incremental replacement works
How the pieces typically fit together on this kind of engagement.
StaffSame tasks, new screens
CustomersPortals and email
Other systemsFiles, feeds and APIs
Routing layerSends each request to old or new code
Legacy systemShrinks as functions move across
New componentsTested, documented and supported
Migrated dataKept in sync until the final cutover
Common use cases
Where this work usually applies
Practical patterns rather than industry labels. The shape of the problem matters more than the sector.
-
Use case 01
VB6 and Delphi desktop applications
Line-of-business tools still running on Windows desktops, moved to a supported platform or rebuilt as web applications one screen at a time.
-
Use case 02
Microsoft Access business systems
Multi-user Access files on a shared drive, moved to a proper database server with a web front end, keeping the reports people depend on.
-
Use case 03
Aging PHP applications
Portals and sites on old PHP versions or abandoned frameworks, upgraded in steps, secured and brought under version control with automated tests.
-
Use case 04
.NET Framework to modern .NET
Web Forms sites, WCF services and Windows services upgraded or re-platformed onto current .NET, ready to run on Linux, in containers or in the cloud.
-
Use case 05
Systems on unsupported servers
Applications tied to an old Windows Server or SQL Server installation, moved to supported infrastructure with monitoring, and backups that are test-restored on a schedule.
-
Use case 06
Software with a missing supplier
Applications whose original developer has disappeared, sometimes with incomplete source code: documented from the running system and its database, then stabilized or rebuilt.
Our approach
How we handle this kind of work
The parts of our method that matter most for legacy modernization.
- 01
Assess before touching anything
We read the code, map the data and talk to the people who use the system, then recommend the smallest change that removes the real risk. Sometimes that's no change at all.
- 02
Pin down today's behavior with tests
Characterization tests capture what the system actually does, odd results included, so we can rework the internals and prove the outputs haven't moved.
- 03
Replace in slices, never all at once
New components take over one function at a time. Each slice goes live on its own, so every step is small and the old system stays available as a fallback.
- 04
Keep the rules, lose the baggage
An odd rounding rule or a special case for one large customer is often the most valuable thing in old code. We find those rules, write them down and carry them forward on purpose.
- 05
Make every step reversible
Each release has a tested way back, data changes are rehearsed on copies first, and cutovers are scheduled around your calendar, not ours.
Project stages
From first conversation to delivery
Each stage has a defined output and a review point, so you always know where the work stands.
How our process works-
01
Assess
A review of code, data, hosting and dependencies, interviews with users, and a written report with options and costs.
-
02
Stabilize
Source control, a repeatable build, verified backups, urgent security fixes and characterization tests around the critical paths.
-
03
Upgrade
Language, framework, library and operating system upgrades in small, tested steps, each one released before the next begins.
-
04
Replace
The parts worth replacing are rebuilt alongside the old system and switched over one function at a time.
-
05
Cut over
Final data migration, a rehearsed switchover, parallel running where it's justified, and a rollback kept ready.
-
06
Retire
Old components switched off, data archived under your retention rules, unused licenses canceled and a patching schedule agreed for what remains.
Capabilities
What we bring to this work
Only the capabilities that matter for this service, and nothing we wouldn't actually recommend.
Assessment
- Code and dependency audits
- Vulnerability scanning
- Third-party license review
- Database and data quality review
- Business rule extraction
- Documentation recovery
Engineering
- Characterization and regression tests
- Source control and repeatable builds
- Framework and runtime upgrades
- Refactoring for testability
- Strangler-fig replacement
- API layers around legacy code
Transition
- Data migration and reconciliation
- Parallel running and output comparison
- Staged and blue-green releases
- Rollback planning and rehearsal
- Decommissioning and archiving
- Monitoring and patch schedules
Delivery and engagement
Typical timelines
Legacy work carries more unknowns than a new build, which is why the assessment comes first and later phases are quoted once we've seen the code. The size and state of the source, data quality and testing time on your side all shape the schedule.
Assessment and recommendations2 to 3 weeks
Stabilization and platform upgrade1 to 3 months
Staged replacement of a core system4 to 12 months, live in stages throughout
Who it's for
Typical clients for this work
We work with companies, organizations and individuals. The requirement matters more than the size of the buyer.
Businesses
- Companies running core operations on VB6, Delphi, Access or old PHP
- Firms whose original developer or supplier is no longer around
- Teams facing an audit, an insurance renewal or a customer security questionnaire
- Businesses that need an integration their current system can't support
Organizations
- Nonprofits and associations with a member database a volunteer built years ago
- Services that can't afford a day offline while systems change
- Multi-site organizations where copies of the same old tool have drifted apart
Product teams and founders
- Software companies whose first-generation product still pays the bills
- Founders who inherited a codebase through an acquisition or a departing supplier
Related services
Often commissioned alongside this
08
Consulting
Cloud Strategy & Migration
Decide what to move, rebuild, keep or retire, model the real costs, then migrate in planned waves with a tested way back at every step.
From$2,300
04
Development
API & Systems Integration
Connect your CRM, ERP, accounting, store and payment systems so data moves on its own, mapped in writing, retried safely and monitored.
From$2,500
Service FAQ
Questions about legacy modernization
Wouldn't it be simpler to rewrite it from scratch?
Usually not. A full rewrite means paying to rebuild everything the system already does, including rules nobody remembers until they're missing, while you run two systems and wait months for any benefit. Replacing in stages delivers value sooner and keeps each risk small. A rewrite can make sense for a small system on a dead-end platform with well-understood rules, and the assessment will tell you if that's your situation.
What if the source code is missing or incomplete?
It happens, and it's workable. We document behavior from the running application, its database, its reports and the people who use it. That record becomes the specification for recovering what exists, rebuilding the gaps, or replacing the system in stages.
Will our team have to stop work during the changeover?
No. That's the main reason to work in stages. Changes are designed to go live without users noticing anything except fewer problems. Where a switchover can't be avoided, such as the final data migration, we rehearse it on a copy, schedule it for your quietest hours and keep the old system ready to switch back to.
Can you modernize just part of the system?
Yes, and it's often the right call. If the core works and only the reporting or the customer-facing side hurts, we can put an API in front of the old system and build the new part on top, leaving the stable core alone until there's a real reason to touch it.
What does the $2,900 starting price cover?
That's where modernization work starts: an assessment of one application of moderate size, or a contained job such as a framework upgrade on a small, well-understood codebase. Bigger programs are quoted phase by phase once we've seen the code, so you're never committing to a large project blind.
Starting from
$2,900
Final pricing depends on the size and condition of the codebase, data quality, hosting and how much is being replaced. Each phase is quoted separately, in writing, once the assessment is done.
Have a project in mind?
Tell us what you're trying to achieve. We'll come back with a clear view of the scope, the approach and the cost, and if we're not the right fit, we'll say so quickly.