There’s a decade-old .NET system running somewhere in your business right now, and nobody wants to be the one who breaks it. Deploys are rare, nerve-wracking events. The people who understood the original design have mostly moved on. Every proposal to fix it seems to start the same way: a multi-year rewrite, or an expensive off-the-shelf migration that fits the business badly. Both are the wrong first move.
Why big-bang rewrites fail
A rewrite asks for trust up front and pays it back, if it pays it back at all, a year or two later. In the meantime the business keeps changing while the rewrite tries to hit a moving target, the team rediscovers the old system’s undocumented quirks the hard way, usually in production, and the eventual cutover is a single high-stakes weekend where everything has to work at once. We’ve watched this pattern often enough, across other people’s projects, that we simply don’t sell it. If a proposal for your legacy system starts with “we rewrite it from scratch,” that’s worth a second opinion before you sign anything.
The seam-by-seam method
The alternative starts with a short paid audit, not a fixed-price guess. The audit maps the system as it actually is, not as the documentation remembers it: which modules touch which tables, where the real seams are, and which order of extraction ships value earliest. That map becomes the roadmap, and the roadmap is what gets a fixed price attached to it.
From there, services get carved out one seam at a time, starting where the pain is worst. Before each seam moves, characterization tests pin down the existing behavior, quirks included, so the new service has to prove it matches the old one before it takes real traffic. The old system keeps running alongside the new one the whole time, with events or a message bus carrying data between them, so both can be compared on live output instead of a demo.
Each domain follows the same rhythm: extract, run in parallel, compare outputs, cut over only once they match, then decommission the old path. Weekly demos show real transactions moving through the new services, which is a different kind of proof than an architecture diagram.
How this played out on an actual ERP
We ran exactly this process on a decade-old ERP where finance, inventory, and HR all ran through one aging .NET Framework monolith with a shared database and no meaningful test coverage. The one non-negotiable was that the company runs on this system every day: no freeze, no big-bang cutover, no month where invoices went out late because of a migration.
The audit came first and became the fixed-price roadmap. Finance moved first, then inventory, then HR, each one carved onto modern .NET Core, with Kafka carrying events between the monolith and the new services so both could run side by side. Azure hosted the new estate with infrastructure defined as code. Each domain moved only after its new service had matched the old one’s output on real data, not synthetic test cases.
Why it worked
Rewrites fail when trust is demanded up front. This approach never asked for it: the legacy system stayed the safety net until each replacement had earned its place in production. The business kept operating through the entire engagement, the risk arrived in weekly slices instead of one terrifying weekend, and the client ended up with a modern .NET estate their own team can hire for and extend, rather than a system only the original vendor understands.
When a rewrite might still make sense
To be fair to the other option: if a system is genuinely small, if the domain model itself is wrong rather than just the technology underneath it, or if the business is about to change so completely that the old behavior isn’t worth preserving, a rewrite can be the honest answer. Even then, we’d still start with an audit rather than a guess, because you want to know that before you commit budget to a year-long project, not after.
If a legacy .NET system is the thing nobody wants to touch at your company, that’s exactly the kind of project we take on. See legacy system modernization for what that looks like end to end, or get an estimate: a free scope call, and if it starts with an audit, we’ll say so on the call.