Legacy .NET, moved to .NET 10. With tests that prove nothing changed.

.NET Framework is past its useful life, and every quarter you wait makes the move more expensive, not less.

Three things are usually true at once by the time someone calls. The runtime is unsupported, which your security and compliance people already treat as a problem. Hiring anyone who wants to maintain a decade-old stack has quietly become impossible. And the obvious alternative, a from-scratch rewrite, is a six-figure bet that breaks behaviour nobody on the team fully remembers building.

Migration is the narrow path between those. Done properly it keeps everything that works and changes only what the platform forces.

One service, and deliberately nothing around it. That narrow line is what lets me quote a fixed price and hold it.

“Isn’t AI-generated migration risky?”

It would be, if the AI had the final say. It doesn’t. The honest answer is structural, and it comes in three parts.

1. i.
   AI does the mechanical work. The repetitive 80%, project conversions, dependency mapping, the rote API transforms, is what tooling is good at. That is where the speed, and the lower price, come from.
2. ii.
   Tests decide whether it’s correct. Before I change a line, I write tests that capture how your app behaves today. The migrated code has to reproduce that exactly. The tests are the judge, not my opinion and not the model’s.
3. iii.
   A named person owns every change. I review each commit and I’m accountable for the result. No rotating team, no offshore black box, no “the tool did it.”

Six steps, run in this order every time. I sell the method, not the hours.

1. 01
   Inventory. An automated scan of every project, dependency and framework target, risks flagged up front.
2. 02
   Pin the target. Lock to .NET 10 LTS and map each dependency to a modern equivalent, or a replacement where none exists.
3. 03
   Characterize. Write the tests that lock in today’s behaviour, before touching the code.
4. 04
   Migrate. AI-accelerated transforms, reviewed by me, committed in small steps you can read.
5. 05
   Prove parity. The full suite runs green against the migrated code. Acceptance is that result, not a feeling.
6. 06
   Handoff. A building repository, a migration report, a readable changelog, and a walkthrough call. Then your team deploys.

Phased, because honest fixed pricing means reading the code first.

A blind fixed bid on legacy .NET is how people lose money: the hidden COM interop, the undocumented logic, the Web Forms surprise. So I don’t guess. A small fixed-price assessment reads your actual code and produces the migration quote.

The assessment is $2,500 to $5,000, takes two to four days, and the whole fee is credited against the migration if you proceed. If it doesn’t give you a clear, actionable plan, you don’t pay for it.

Your real number comes from the assessment. Half to start, half on acceptance, where acceptance means the test suite is green and the agreed checklist is met. You own all the resulting code.

I’d rather show you than tell you. There’s a public sample migration: a real open-source .NET Framework app, taken end to end, every commit and the full passing test suite out in the open. No client permission needed, nothing to take on faith.

Read the full writeup in the field notebook →