<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Oliver Fries on Medium]]></title>
        <description><![CDATA[Stories by Oliver Fries on Medium]]></description>
        <link>https://medium.com/@fries-dotnet-legacy?source=rss-3cddc1ffa27d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*WQ10UwhUNoP7bGiG7TNTtg.png</url>
            <title>Stories by Oliver Fries on Medium</title>
            <link>https://medium.com/@fries-dotnet-legacy?source=rss-3cddc1ffa27d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 23:09:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@fries-dotnet-legacy/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The most dangerous line in your codebase starts with “normally, Sarah does this.”]]></title>
            <link>https://fries-dotnet-legacy.medium.com/the-most-dangerous-line-in-your-codebase-starts-with-normally-sarah-does-this-b080b6df804a?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/b080b6df804a</guid>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[legacy-systems]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 09:50:34 GMT</pubDate>
            <atom:updated>2026-08-10T09:50:34.214Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Before you rewrite anything, walk one real release from end to end.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_34UvFw-isSoyAQ1dnqipA.png" /><figcaption>Created by ChatGPT</figcaption></figure><p>Some systems look perfectly healthy right up to the moment someone tries to change them.</p><p>The projekt runs smoothly, orders go through and the dashboard is green. In the status meeting someone calls it “stable,” and technically they’re right.</p><p>Then a release gets scheduled, and the mood in the room changes.</p><p>Suddenly there are extra meetings and someone checks whether the one colleague who understands the deployment script is on vacation. QA starts their testing run which takes 1 month, while development and hotfixes are still made. A one-line change in the order module means retesting shipping and reporting too, “just to be safe.” And nobody can say with a straight face what production will actually look like on Monday.</p><p>I’ve spent most of seventeen years in that gap: the distance between software that runs and software you can still change without holding your breath. In manufacturing, where a bad release can stop a physical line and burn real money by the hour, you feel that gap in your stomach.</p><p>When releases won’t work and when all changes seem to take longer than a week before you are in trouble. Not Microservice, kubernetes, Rewrite, AI or a six-month modernization program seems to help. You start to ask the most pending question:</p><blockquote>What is actually wrong with this system?</blockquote><p>And you got those people that say that it is “just” Legacy software and it is normal that system work that way when they age.</p><h3>Legacy is not an age</h3><p>We use “legacy” as a polite word for “old” and that’s the first mistake.</p><p>I’ve worked on fifteen-year-old .NET applications that were a pleasure to change, and three-year-old ones that already made the whole team flinch. Age isn’t the variable here. What matters is the relationship between the system, the people who maintain it, and the changes the business keeps asking for.</p><ul><li>Can the team predict what a change will break?</li><li>Can someone who has never seen a module get productive in it within a day? Can you release without booking four specific people into one meeting?</li><li>When something breaks at 22:00, does the system come back in ten minutes, or does it eat your whole night?</li></ul><p>Legacy is the condition where the risk and effort of change start to outgrow your ability to change the system safely. That’s the whole definition.</p><p>And it isn’t academic, because it decides what “modernization” even means. If age is the problem, swapping old tech for new tech sounds reasonable. But if changeability is the problem, moving the same tangled dependencies and the same undocumented assumptions onto a shinier stack buys you almost nothing. You just paid to relocate the pain.</p><p>And if the organisation around the software does not change as well you can rewrite as often as you want. You’ll still get the same messy software you had before just in new clothes.</p><h3>Diagnose before you prescribe</h3><p>Struggling systems never suffer from a shortage of proposed fixes.</p><ul><li>“We need more tests.”</li><li>“The build is too slow.”</li><li>“We should split the monolith.”</li><li>“We need better docs.”</li><li>“Let’s just rewrite it.”</li></ul><p>Some of those might be right, but the problem is the jump straight from discomfort to intervention, without ever checking whether you’re treating the real bottleneck. I’ve reached for the rewrite button myself more than once, and regretted it more than once. At first it feels productive and as said before it usually just moves the mess somewhere newer.</p><p>One Time we rewrote a whole business Xamarin Native App and used MAUI. We started thinking about services and decouplings and using depency injection and our own “contracting” system in between modules. But we haven’t thought it trough till the end. We made some really great architectural decisions but then our release manager came and said we need to be finished in 3 months. Well …. that didn’t work out. So the whole team of 70 something developers from the old project where put on our project and speed was the main concern. All while no one knew what features exactly need to be in the rewrite and what users actually used. Simply “put all of them in” was the management answer. And in the end we made some really great progress with the new application, but it took a while to remove all the alpha issues and instead of previous messy code we now had the problem that every major update from one of the core libraries behind all of it took weeks to proceed.</p><p>So slow down and do the dull thing first. Otherwise you get out of the frying pan into the fire.</p><h3>Put numbers next to the feeling</h3><p>Start with what you probably already have but don’t really know yet: Deployment Frequency, Lead Time for Changes, Change Failure Rate, Mean Time to Restore. These values are inside your project management tool and git history you just need to extract them (If you need help for that write me a message).</p><p>Then add an honest estimate of technical debt on top, because delivery metrics never describe the whole system on their own.</p><p>The metrics aren’t the interesting part as most engineers can recite them. The interesting part is treating each one as a signal, not a verdict.</p><p>A long lead time might mean tightly coupled architecture. It might also mean three days waiting for manual QA and one more day waiting for a manager to click “approve.”</p><p>Same number, completely different problems.</p><p>Spend a week shaving a 47-minute build down to 20, and you’ve done nothing about the four days of waiting sitting right next to it. A metric points you at the place to look; it never tells you what you’ll find when you get there.</p><h3>Follow one real release</h3><p>Here’s the most useful technique I know, and it’s almost embarrassingly low-tech: walk through one recent release from beginning to end step by step with a notebook by your side and don’t rely on any documentation.</p><p>While doing that try to answer these questions:</p><ul><li>Who prepared the build?</li><li>Who approved it, and how, a pipeline gate or a thumbs-up in a chat?</li><li>What happened by hand?</li><li>Where did somebody sit and wait?</li><li>Which script does everyone run and nobody wants to open?</li><li>Which step quietly begins with “normally, Sarah does this”?</li></ul><p>A walkthrough surfaces what static analysis can’t: the invisible operating system around your software. The manual knowledge, the informal approvals, the workaround that’s been load-bearing for two years, the environment ritual nobody ever wrote down.</p><p>That matters, because most legacy problems don’t live neatly inside source files as they live in the gaps between Git, CI, QA, infrastructure, people, and production. Saidly there is no <em>grep</em> command for that</p><h3>Let Git show you where it actually hurts</h3><p>Once the delivery process is visible, look at the code. But don’t treat every ugly class as equally urgent, mostly that will get you into a spiral you cannot escape easily. Instead ask a narrower question: where does complexity actually collide with change?</p><p>An 8,000-line monster nobody has touched in six years is ugly, but if it just sits there running, it probably isn’t your problem this quarter. A merely awkward module that gets edited every second sprint can cost you far more.</p><p>Your repository history already knows this and a hotspot analysis uses the commit history to find the places where frequent change and high complexity overlap, the spots where you pay the maintenance tax again and again. The point isn’t another code-quality score to feel bad about as it’s about finding where the money is leaking out.</p><p>It’s also a good antidote to modernization driven by taste. Remember that not all technical debt deserves your attention today, even those mind bugging ill formatted and ugly construct someone wrote 3 years ago and which would be an “easy fix”. The debt sitting directly on the path of constant change almost certainly does.</p><h3>Your biggest single point of failure might be a person</h3><p>There’s a kind of coupling no architecture diagram shows: <strong>people</strong>.</p><p>A team can have five developers and still run a bus factor of one for deployment, for the payment integration, or for that one strange interface to the ERP. The danger isn’t that one person wrote most of the code, but that only that same person remembers why the odd decision was made, knows the production quirks, takes the incidents at two in the morning, and teaches everyone else how the thing works. Except the teaching never happens and only that person every really works on that code.</p><p>At that point concentrated knowledge has turned into operational risk. And “we should document more” is not a serious answer to it.</p><p>Better questions would be which areas would stop moving if that person didn’t show up next Monday? And which of them needs pairing, a runbook, a written decision record, or a real handover, not someday but on the calendar?</p><p>Otherwise a single bad morning where that person does not come to work and hell breaks loose.</p><h3>The point isn’t the analysis. It’s a decision.</h3><p>Here’s the trap waiting at the end of every diagnosis: the diagnosis becomes the project. Another workshop, architecture map and another backlog of findings everyone admires and nobody touches.</p><p>So treat modernization as a hypothesis, not a master plan. You believe one specific change will improve the system. Good. Change that one thing on purpose, give it about 30 days, and measure again. Watch whether the system actually reacts. You need a 30-day evidence phase, and I’ve never found a better way to put it. Only after that rough period you know if your changes really helped.</p><p>After that, the choice gets much clearer. Keep stabilizing in small steps. Dig deeper into the architecture. Or start preparing a replacement, honestly this time, because continued operation can’t be justified anymore.</p><p>The numbers won’t make that call for you. Budget, criticality, office politics, and how much longer the software has to live all still matter. The numbers just narrow the argument down to something a room of adults can actually decide. People make the decision. The evidence keeps them honest.</p><h3>Is this you?</h3><p>If your team already ships several times a day, understands its own production environment, and can touch critical code without flinching, then none of this is for you. Enjoy your work. It’s rarer than it should be, but sadly it seems like a unicorn project.</p><p>But if you’ve said, or heard, any of these lately:</p><ul><li>“We don’t touch that module unless we absolutely have to.”</li><li>“Only two people know how the release really works.”</li><li>“It’s been stable for years.”</li><li>“We should rewrite this at some point.”</li></ul><p>…then start small. You don’t need to understand every line of a legacy system before you can improve it. You need just enough evidence to see where change gets dangerous, where time disappears, where knowledge gets hoarded, and which single intervention is worth trying first.</p><p>That’s a much smaller problem than “modernize the legacy system.” For most teams, it’s also the better place to begin.</p><p>So before your next planning meeting, go find one sentence: the step in your release that starts with “normally, [name] does this.” That sentence is your diagnosis, already written. What’s yours?</p><p>If you’re interested, I am writing a small handbook regarding this topic. If that is interesting four you, write me a message and I can send you the preview.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b080b6df804a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eighteen Years In, We Still Can’t Agree on How to Build Software]]></title>
            <link>https://fries-dotnet-legacy.medium.com/eighteen-years-in-we-still-cant-agree-on-how-to-build-software-a748dd79344d?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a748dd79344d</guid>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Sun, 21 Jun 2026 20:15:16 GMT</pubDate>
            <atom:updated>2026-06-21T20:15:16.331Z</atom:updated>
            <content:encoded><![CDATA[<h4>Scrum didn’t fix us in 2008, and it hasn’t in 2026 either. Maybe the framework was never the point.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ur2rHM-785mOTUTiNQ2QuQ.png" /></figure><p>Second year of my apprenticeship, somewhere around 2009. SVN was the new hotness, Git was the thing the cool kids kept mentioning, and “agile” still sounded slightly suspicious to the people signing the paychecks. We worked off specs and requirement documents thick enough to prop a door. Then management discovered Scrum.</p><p>Discovered is generous. What actually happened: someone decided we’d now stand in the hallway for fifteen minutes every morning. Each of us reported what we did yesterday. Nobody listened to anybody else. The stated goal was better collaboration and fewer bugs. The real result was fifteen minutes of standing, then everyone went back to their corner and built exactly what they were building before.</p><p>I was 19 or so and figured I just didn’t get it yet.</p><p>Then a core module fell over. Some students had written it a decade earlier, it had no tests, and a bug in it took down more or less everything. The fix? A mandated 56-hour week. “Just to make it working again.” “Just for one month.” Of course it ran into a second month. By the third, developers started getting “sick,” one after another, until there was barely anyone left to enforce the crunch on. Funny how that works.</p><p>That was the first time I understood, in my gut rather than my head, that something was broken in how we build software. Not the code. The whole arrangement around it.</p><h3>I spent years blaming the implementation</h3><p>For most of my career I had one explanation for every Scrum failure I watched: you’re just not doing it right. Not by the book. Get the ceremonies exactly correct, run the retros properly, size the stories honestly, and it’ll click.</p><p>I really believed that. Through university, through job after job, the same dysfunction kept showing up and I kept telling myself the same thing. These people are sloppy. A team that follows the manual to the letter would be fine.</p><p>Reading Martin Fowler, Kent Beck, and David Farley over the years slowly took that explanation apart. Their point was never “do the ritual better.” It was closer to the opposite: the ritual was never doing the heavy lifting in the first place.</p><h3>What Fowler called “Flaccid Scrum”</h3><p>Back in 2009, Fowler wrote about a pattern he called <em>Flaccid Scrum</em>. A team adopts Scrum, runs all the events, hits velocity for a while, and then delivery grinds slower and slower. The cause isn’t the process. It’s that nobody kept the technical base healthy. No serious refactoring, weak testing, design rot left to accumulate, until the codebase fights every new feature. His argument was never that Scrum is bad, but that a process only helps if the team actively keeps technical debt in check.</p><p>Funny that I discovered that article just a few years ago while I had the same issues the time he wrote that article.</p><p>That landed for me harder than any certification ever did. The hallway standup in 2009 wasn’t the failure. The failure was a ten-year-old module with no tests that one bug could flatten. Scrum just gave us a tidy schedule to feel busy on top of it.</p><p><strong><em>A framework organizes how people talk. It does nothing about whether the code underneath can survive being changed.</em></strong></p><p>And here’s the uncomfortable part: this is more true in 2026, not less. The current Scrum conversation has circled right back to engineering fundamentals, technical quality, a Definition of Done that actually means something, transparency about the state of the code. Run all the events but skip the tests, the refactoring, the architecture work, and the real problem sits there untouched.</p><h3>So is it better now? Honestly, no</h3><p>Leave AI out of it for a second. The processes haven’t matured. People haven’t changed. Developers don’t collaborate noticeably better or ship noticeably faster than they did when I started. It’s still, underneath everything, a communication problem wearing different clothes each year.</p><p>What did change is who runs the show. Scrum now gets pushed into companies, almost dogmatically, by people with a psychology or business degree and a two-day certificate. Dashboards everywhere. A Scrum Master who has actually written production code is about as rare as a developer who’s fully happy with their current project. There’s always something:</p><ul><li>Pressure from the AI hype, layered on top of everything else</li><li>Projects already behind before they start</li><li>Requirements nobody can pin down</li><li>Last-minute changes from some other department</li><li>Teams ranked against each other on story points delivered</li><li>Deadlines before even a single developer saw the requirments / User Story</li><li>More managers in the room than engineers</li></ul><p>No tool fixes that list. AI included.</p><h3>AI makes a good base better and a bad base worse</h3><p>I’m not anti-AI. It’s useful, and the numbers back that up. In GitLab’s 2026 German DevSecOps survey, 62% of respondents use AI for testing, 63% use it for documentation, and 49% already trust it with part of their code reviews. Those are real gains on the boring, repetitive parts of the job, exactly where you want a machine.</p><p>But notice what all of that is: checking, documenting, reviewing, spotting patterns. AI is an amplifier of your engineering discipline, not a substitute for it. Point it at a clean codebase with real tests and a clear Definition of Done, and it makes a good team faster. Point it at the 2008 module with no tests, and it’ll help you generate more untested code, faster, while the delivery graph looks great for a quarter.</p><p>That’s the trap. More output is not more quality. A weak technical foundation doesn’t disappear under AI. It just gets buried quicker, under more code, with a nicer dashboard on top.</p><p>The decision about whether something is actually <em>done</em> stays human. Security, compliance, architecture, the business call on whether it ships, none of that transfers to a tool that makes suggestions but carries no responsibility. The human bottleneck in problem-solving and understanding isn’t going anywhere, no matter how good the autocomplete gets.</p><h3>The question I keep circling back to</h3><p>Here’s what actually bothers me, eighteen years in. Why can’t we, as a field, agree on a basic standard of craft? A shared baseline everyone can lean on.</p><p>Instead we get a new mutation of Scrum or XP every couple of years, and everyone does it slightly differently. And honestly, some of that variety is correct. People are different. The process has to fit the team, and the team has to fit the process. A standard that ignores that would be worse than no standard.</p><p>But that’s not why we don’t have one. We don’t have one because the process almost never grows out of the team doing the work. It gets handed down from somewhere higher up, by someone with no real connection to writing software, and dropped on people who then have to live inside it.</p><p>The rare times I’ve seen a team hold genuine decision-making power over how they work, the product was usually better. Not always pretty, not always the same shape twice, but better. Even then, every one of those teams ran its own variant. None of them matched.</p><p>So maybe the honest answer is that there is no single handcraft standard coming, because software isn’t an assembly line, even tough with the AI hype many managers want it to be. It’s knowledge work, it’s social, it’s tangled up in context. What we could share is a floor, not a blueprint: real tests, real refactoring, a Definition of Done with teeth, honest metrics, teams that actually own their decisions, and protection from the kind of crunch that sent my whole department home “sick” in 2009.</p><p>That floor is what Fowler was pointing at in 2009. It’s what the better practitioners have been saying the whole time. We just kept arguing about the ceremonies instead.</p><p>The framework was never going to save us. The engineering underneath it is the part that does.</p><p>If you’ve worked somewhere that actually let the team own its own process, I want to hear how it went, and whether the result held up. And if you’re the one currently rolling out a process onto a team you’ve never written code with, maybe ask them first.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a748dd79344d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to migrate ASP.NET Web Forms to .NET 10 without a big rewrite]]></title>
            <link>https://fries-dotnet-legacy.medium.com/how-to-migrate-asp-net-web-forms-to-net-10-without-a-big-rewrite-6edb295ec350?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/6edb295ec350</guid>
            <category><![CDATA[c-sharp-programming]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[legacy-code]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Sun, 14 Jun 2026 05:46:00 GMT</pubDate>
            <atom:updated>2026-06-14T05:46:00.529Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why “just change the target framework” was never a plan and the page-by-page approach that actually ships</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g4qxsLtAmFQ82I1RJ4ArxQ.png" /></figure><p>Sooner or later, someone in a planning meeting says it out loud: <em>“Can’t we just retarget the old Web Forms app to .NET 10 and recompile?”</em></p><p>I understand the hope behind it. The codebase has paid for itself ten times over, nobody wants to open it, and management would love a one-line answer they can put on a slide. But the honest reply is the one that kills the mood: no. You cannot keep the Web Forms UI unchanged, because the runtime it depends on no longer exists.</p><p>Web Forms is built on System.Web, the ASP.NET page lifecycle, server controls, ViewState, HttpModules and HttpHandlers, Web.config behavior, and an IIS-hosted model. None of that is present in modern ASP.NET Core. There is no realistic path where you open an old project, flip the target to net10.0, compile, and deploy it unchanged.</p><p>Here’s the part that survives the meeting, though: you don’t need a big-bang rewrite either.</p><p>That distinction is the whole article. A sensible migration isn’t about pretending Web Forms runs on .NET 10. It’s about preserving what still has business value, moving risk in controlled steps, and replacing the runtime and the UI layer gradually — instead of stopping product development for eighteen months. The goal isn’t “rewrite everything.” It’s “keep the business running while the system moves, page by page, module by module, into a modern ASP.NET Core architecture.”</p><p>By the end of this you’ll know what to reuse, how to pick a target stack, how to run the old and new apps side by side with a reverse proxy, and the order of operations that keeps a migration from stalling. That last part — the order — is where the Strangler Fig pattern earns its keep.</p><h3>The reality check: what can you actually reuse?</h3><p>A typical Web Forms application is a stack of layers that have usually grown into each other: .aspx markup, code-behind, user controls, master pages, server controls, ViewState-dependent UI logic, business rules, validation, data access, file access, background jobs, authentication, session and cache usage, HttpModules, HttpHandlers, and Web.config configuration.</p><p>These do not share the same migration value, and treating them as if they do is how budgets evaporate. The .aspx UI usually has to be rebuilt. The business rules often don&#39;t. The database normally stays. And many service classes move with limited changes — especially the ones already written as plain C# rather than tangled up with Page, HttpContext.Current, Session, Request, Response, or Web Forms controls.</p><p>So the effort is lumpy, not evenly spread. It helps to sort the system into groups before you commit to anything:</p><p>Part of the system Migration expectation Business logic in plain C# Often reusable after cleanup Data access Reusable if decoupled; often needs EF / provider updates .aspx UI and server controls Must be rebuilt in Razor Pages, MVC, Blazor, or another modern UI framework Web.config / Global.asax / HttpModules Must be moved into ASP.NET Core configuration and middleware Session / ViewState-heavy flows Need explicit redesign Authentication Usually needs careful migration planning Third-party Web Forms controls Often a major blocker — inventory these early</p><p>Which is why the first phase shouldn’t be coding. It should be inventory.</p><h3>Choose the target stack deliberately</h3><p>Before you write a line, decide what the new application is supposed to become. The failure mode here is quiet but expensive: pages get migrated into whatever style each developer prefers that week, and you end up building a second legacy system before the first one is gone.</p><p>For Web Forms teams, a few targets come up repeatedly:</p><p>Current situation Suggested target Many page-based CRUD screens, intranet app, forms over data Razor Pages Clear need for controllers, APIs, explicit URL design, frontend separation ASP.NET Core MVC Heavy event-driven UI, rich interactions, devs used to UI events Blazor Server Want to move gradually with MVVM-style patterns and less UI disruption DotVVM Full frontend redesign already planned ASP.NET Core API + SPA</p><p>For most business applications, Razor Pages is the most pragmatic first choice. It’s page-centric, explicit, testable, and close enough to the mental model of Web Forms without trying to imitate it.</p><p>Blazor Server is tempting because the component-and-event model feels familiar to anyone used to server-side UI events — but it isn’t a drop-in replacement. It brings its own hosting, state, scaling, and circuit behavior, and you have to understand all four. MVC makes sense when the migration is also an architectural cleanup, with stricter separation of APIs, workflows, view models, and URLs.</p><p>The point isn’t to pick the trendiest option. It’s to pick the one that lowers migration risk.</p><h3>The migration pattern: Strangler Fig with a reverse proxy</h3><p>For any non-trivial Web Forms application, the safest pattern is to surround the old system rather than replace it in one cut:</p><ol><li>Keep the old Web Forms app running on .NET Framework.</li><li>Stand up a new ASP.NET Core app targeting .NET 10.</li><li>Put both behind one domain.</li><li>Route migrated URLs to the new app.</li><li>Route everything else back to the old one.</li><li>Move one page, workflow, or module at a time.</li><li>Remove the old app only when the important routes are gone.</li></ol><p>This is the Strangler Fig pattern, and the name is literal. The old system isn’t switched off. It’s grown over, until more and more responsibility lives in the new application and the old one is finally just dead weight you can cut.</p><p>A simplified routing model might look like this:</p><p>URL Served by /Orders New ASP.NET Core app /Orders/Details/123 New ASP.NET Core app /Admin/Users.aspx Legacy Web Forms app /Reports/Monthly.aspx Legacy Web Forms app /Account/Login Shared or migrated authentication flow</p><p>There are two common ways to wire that up.</p><h3>Option 1: IIS URL Rewrite</h3><p>In most existing Web Forms environments, IIS is already the operational center, which makes URL Rewrite a low-friction first step. IIS takes the request and decides whether to hand it to the legacy app or the new one:</p><pre>example.com<br>│<br>├── /legacy-paths/*  → Web Forms app on .NET Framework<br>│<br>└── /new-paths/*     → ASP.NET Core app on .NET 10</pre><p>This works well when you want to keep the old hosting model mostly intact and introduce ASP.NET Core gradually. The catch is that routing logic now lives partly outside the application, in IIS configuration. That can be fine — but those rewrite rules are production logic, and they need versioning, documentation, and the same discipline you’d give any other deployed code. Treat them that way and they’re an asset. Forget them and they’re a 2am mystery.</p><h3>Option 2: ASP.NET Core with YARP</h3><p>The other approach flips the front door. You put the new ASP.NET Core app in front and use YARP as a reverse proxy for routes that haven’t been migrated yet. If a route exists in the new app, ASP.NET Core handles it; if not, the request is proxied back to Web Forms.</p><pre>Browser<br>  ↓<br>ASP.NET Core .NET 10 app<br>  ├── handles migrated routes<br>  └── proxies legacy routes to Web Forms via YARP</pre><p>A minimal Program.cs for that setup:</p><pre>var builder = WebApplication.CreateBuilder(args);<br>builder.Services.AddRazorPages();<br>builder.Services.AddReverseProxy()<br>    .LoadFromConfig(builder.Configuration.GetSection(&quot;ReverseProxy&quot;));<br>var app = builder.Build();<br>app.UseHttpsRedirection();<br>app.UseStaticFiles();<br>app.UseRouting();<br>app.UseAuthentication();<br>app.UseAuthorization();<br>app.MapRazorPages();<br>app.MapReverseProxy();<br>app.Run();</pre><p>And the matching appsettings.json section:</p><pre>{<br>  &quot;ReverseProxy&quot;: {<br>    &quot;Routes&quot;: {<br>      &quot;legacy&quot;: {<br>        &quot;ClusterId&quot;: &quot;legacyCluster&quot;,<br>        &quot;Match&quot;: {<br>          &quot;Path&quot;: &quot;/legacy/{**catch-all}&quot;<br>        }<br>      }<br>    },<br>    &quot;Clusters&quot;: {<br>      &quot;legacyCluster&quot;: {<br>        &quot;Destinations&quot;: {<br>          &quot;legacyApp&quot;: {<br>            &quot;Address&quot;: &quot;https://legacy.internal/&quot;<br>          }<br>        }<br>      }<br>    }<br>  }<br>}</pre><p>In a real system the matching gets more specific — you might proxy /Reports/{**catch-all} or the old .aspx paths while letting migrated modules go straight to ASP.NET Core. This gives the new app real control over routing, authentication, headers, and observability. The trade is that the new app becomes operationally critical from day one, which means monitoring, rollback, and logging have to be in place before you cut anything over, not after.</p><h3>Step 1: inventory the application</h3><p>Before the first Razor Page, write down what you actually have. At minimum:</p><ul><li>all .aspx pages and .ascx user controls</li><li>master pages and third-party controls</li><li>routes and navigation entry points</li><li>code-behind files carrying business logic</li><li>direct database calls and file system access from the UI</li><li>dependencies on HttpContext.Current</li><li>usage of Session, Cache, Application, Request, Response</li><li>authentication and authorization mechanisms</li><li>HttpModules, HttpHandlers, and Web.config settings</li><li>scheduled jobs and external integrations</li><li>which pages are business-critical, and which are barely used</li></ul><p>Then classify every page by risk. A simple table is enough:</p><p>Module Business criticality Technical complexity Usage Migration priority Order entry High High High Pilot only after prep Customer lookup Medium Low High Good early migration Legacy report export Low Medium Low Later Admin settings High Medium Low Needs security review</p><p>The best first candidate is almost never the most important page. You want one that’s used enough to prove the pattern, simple enough to migrate safely, connected to real business logic, and not so critical that a stumble takes the business down with it. A good pilot builds confidence. A bad pilot confirms everyone’s quiet suspicion that this was a mistake.</p><h3>Step 2: separate business logic from Web Forms</h3><p>Most failed migrations I’ve watched start at the UI. That’s backwards. Start by pulling logic out of the code-behind, where it tends to hide in plain sight.</p><p>A typical button-click handler looks like this — UI, parsing, validation, database access, and user feedback all welded into one method:</p><pre>protected void SaveButton_Click(object sender, EventArgs e)<br>{<br>    var customerId = int.Parse(CustomerIdTextBox.Text);<br>    var orderDate = DateTime.Parse(OrderDateTextBox.Text);<br>using var connection = new SqlConnection(<br>        ConfigurationManager.ConnectionStrings[&quot;Default&quot;].ConnectionString);<br>    connection.Open();<br>    var command = new SqlCommand(<br>        &quot;INSERT INTO Orders (CustomerId, OrderDate) VALUES (@CustomerId, @OrderDate)&quot;,<br>        connection);<br>    command.Parameters.AddWithValue(&quot;@CustomerId&quot;, customerId);<br>    command.Parameters.AddWithValue(&quot;@OrderDate&quot;, orderDate);<br>    command.ExecuteNonQuery();<br>    ResultLabel.Text = &quot;Order saved.&quot;;<br>}</pre><p>You can’t migrate that cleanly because there’s nothing to migrate cleanly — it’s five concerns in one handler. The intermediate step is to extract the use case so it stands on its own:</p><pre>public sealed class CreateOrderRequest<br>{<br>    public int CustomerId { get; init; }<br>    public DateTime OrderDate { get; init; }<br>}<br>public interface IOrderService<br>{<br>    Task CreateOrderAsync(CreateOrderRequest request, CancellationToken cancellationToken);<br>}<br>public sealed class OrderService : IOrderService<br>{<br>    private readonly IOrderRepository _orders;<br>    public OrderService(IOrderRepository orders)<br>    {<br>        _orders = orders;<br>    }<br>    public Task CreateOrderAsync(<br>        CreateOrderRequest request,<br>        CancellationToken cancellationToken)<br>    {<br>        if (request.CustomerId &lt;= 0)<br>            throw new InvalidOperationException(&quot;Customer is required.&quot;);<br>        return _orders.CreateAsync(request, cancellationToken);<br>    }<br>}</pre><p>The Web Forms page can still call that service today. And tomorrow, a Razor Page, an MVC controller, or a Blazor component can call the exact same service. <em>Migrate ownership of behavior before you migrate pages.</em> It’s the single move that keeps every later page from turning into a from-scratch rewrite.</p><h3>Step 3: create the .NET 10 host</h3><p>Once a few boundaries are clear, stand up the new app. For a Razor Pages target:</p><pre>dotnet new webapp -o MyApp.New -f net10.0</pre><p>It doesn’t have to replace anything yet. At first it only needs to start reliably, serve one test page, share your logging approach, read configuration correctly, reach the shared services, point in the right authentication direction, and participate in routing. A minimal Program.cs:</p><pre>var builder = WebApplication.CreateBuilder(args);<br>builder.Services.AddRazorPages();<br>builder.Services.AddScoped&lt;IOrderService, OrderService&gt;();<br>builder.Services.AddScoped&lt;IOrderRepository, SqlOrderRepository&gt;();<br>builder.Services.AddAuthentication(/* configure scheme */);<br>builder.Services.AddAuthorization();<br>var app = builder.Build();<br>if (!app.Environment.IsDevelopment())<br>{<br>    app.UseExceptionHandler(&quot;/Error&quot;);<br>    app.UseHsts();<br>}<br>app.UseHttpsRedirection();<br>app.UseStaticFiles();<br>app.UseRouting();<br>app.UseAuthentication();<br>app.UseAuthorization();<br>app.MapRazorPages();<br>app.Run();</pre><p>Several old Web Forms concepts simply don’t have a home here, so they have to move:</p><p>Web Forms / ASP.NET Framework ASP.NET Core / .NET 10 Global.asax Program.cs, middleware, hosted services Web.config appSettings appsettings.json, environment variables, config providers HttpModules Middleware HttpHandlers Endpoints, middleware, minimal APIs ConfigurationManager IConfiguration HttpContext.Current injected IHttpContextAccessor, only where necessary Web Forms page lifecycle Razor Page handlers, MVC actions, Blazor lifecycle System.Web.Optimization modern frontend build tooling or static file pipeline</p><p>This is the moment it sinks in for most teams: the migration isn’t a syntax change, it’s a hosting and architecture change.</p><h3>Step 4: translate the configuration, don’t copy it</h3><p>Web Forms apps tend to store years of operational knowledge inside Web.config — connection strings, app settings, binding redirects, auth configuration, authorization rules, custom modules, handler mappings, compilation and session settings, IIS-specific behavior. Copying it across verbatim drags all the old assumptions with it. Translate it instead.</p><p>An old Web.config fragment:</p><pre>&lt;appSettings&gt;<br>  &lt;add key=&quot;OrderExportPath&quot; value=&quot;\\fileserver\exports\orders&quot; /&gt;<br>&lt;/appSettings&gt;<br>&lt;connectionStrings&gt;<br>  &lt;add name=&quot;Default&quot;<br>       connectionString=&quot;Server=.;Database=AppDb;Trusted_Connection=True;&quot; /&gt;<br>&lt;/connectionStrings&gt;</pre><p>Becomes a typed section in appsettings.json:</p><pre>{<br>  &quot;AppSettings&quot;: {<br>    &quot;OrderExportPath&quot;: &quot;\\\\fileserver\\exports\\orders&quot;<br>  },<br>  &quot;ConnectionStrings&quot;: {<br>    &quot;Default&quot;: &quot;Server=.;Database=AppDb;Trusted_Connection=True;TrustServerCertificate=True&quot;<br>  }<br>}</pre><p>Bound to a real options class and injected where it’s needed:</p><pre>public sealed class AppSettings<br>{<br>    public string OrderExportPath { get; init; } = string.Empty;<br>}<br>builder.Services.Configure&lt;AppSettings&gt;(<br>    builder.Configuration.GetSection(&quot;AppSettings&quot;));<br>public sealed class OrderExportService<br>{<br>    private readonly AppSettings _settings;<br>public OrderExportService(IOptions&lt;AppSettings&gt; options)<br>    {<br>        _settings = options.Value;<br>    }<br>}</pre><p>Yes, that’s more verbose than reaching for ConfigurationManager.AppSettings. It&#39;s also testable, explicit, and environment-aware — which is exactly what you want the day a production setting needs to differ from staging and you&#39;d rather not redeploy to find out.</p><h3>Step 5: migrate behavior, not server controls</h3><p>The most common mistake is trying to recreate Web Forms control behavior one-to-one. It produces bad ASP.NET Core every time, because Web Forms encouraged a page that <em>pretended</em> to be stateful: controls had server-side identities, events fired on postback, ViewState restored everything, and code-behind reached in and mutated controls directly. Modern ASP.NET Core does not work that way, and fighting it is a losing game.</p><p>So a page like this:</p><pre>&lt;asp:TextBox ID=&quot;CustomerNameTextBox&quot; runat=&quot;server&quot; /&gt;<br>&lt;asp:Button ID=&quot;SaveButton&quot; runat=&quot;server&quot; Text=&quot;Save&quot; OnClick=&quot;SaveButton_Click&quot; /&gt;<br>&lt;asp:Label ID=&quot;ResultLabel&quot; runat=&quot;server&quot; /&gt;</pre><p>shouldn’t be ported mechanically. In Razor Pages you model the request explicitly:</p><pre>public sealed class CreateCustomerModel : PageModel<br>{<br>    private readonly ICustomerService _customers;<br>    public CreateCustomerModel(ICustomerService customers)<br>    {<br>        _customers = customers;<br>    }<br>    [BindProperty]<br>    public CreateCustomerInput Input { get; set; } = new();<br>    public void OnGet()<br>    {<br>    }<br>    public async Task&lt;IActionResult&gt; OnPostAsync(CancellationToken cancellationToken)<br>    {<br>        if (!ModelState.IsValid)<br>            return Page();<br>        await _customers.CreateAsync(Input, cancellationToken);<br>        TempData[&quot;Message&quot;] = &quot;Customer saved.&quot;;<br>        return RedirectToPage(&quot;/Customers/Index&quot;);<br>    }<br>}</pre><p>with a plain Razor view:</p><pre>&lt;form method=&quot;post&quot;&gt;<br>    &lt;div&gt;<br>        &lt;label asp-for=&quot;Input.Name&quot;&gt;&lt;/label&gt;<br>        &lt;input asp-for=&quot;Input.Name&quot; /&gt;<br>        &lt;span asp-validation-for=&quot;Input.Name&quot;&gt;&lt;/span&gt;<br>    &lt;/div&gt;<br>&lt;button type=&quot;submit&quot;&gt;Save&lt;/button&gt;<br>&lt;/form&gt;</pre><p>That isn’t a line-by-line translation, and it shouldn’t be. The wrong question is <em>“which tag helper replaces this server control?”</em> The right one is <em>“what behavior does this page need, and how do I represent it explicitly?”</em> That gap — between replacing a control and rebuilding a behavior — is the difference between migration and imitation.</p><h3>Step 6: handle ViewState honestly</h3><p>ViewState is the conceptual landmine. In a lot of Web Forms systems it quietly preserves page state across requests, and most teams have only a rough sense of how much state it’s actually carrying. In ASP.NET Core that implicit model is gone, and that’s a feature: you’re now forced to decide what state really belongs where.</p><p>Web Forms state pattern Modern replacement ViewState for form values model binding ViewState for temporary messages TempData ViewState for multi-step flows explicit workflow state, database, distributed cache ViewState for UI-only state client-side or component state Session for everything reduce scope; use explicit session only where justified Hidden fields use carefully, validate server-side</p><p>Whatever you do, don’t rebuild ViewState. Recreating hidden server-side state with new tools just imports the old problem in fresh packaging. Use the migration to make state visible instead: every piece of state should have a reason, a lifetime, and an owner. If you can’t name all three, you probably don’t need it.</p><h3>Step 7: migrate authentication carefully</h3><p>Authentication is usually the hardest part of an incremental migration, and it’s hard for a specific reason: it touches every route, so the old and new apps have to agree about who the user is while they’re both live.</p><p>A Web Forms app might use Forms Authentication, ASP.NET Membership, custom role providers, Windows Authentication, cookies, session-based identity, and authorization checks scattered between code-behind and Web.config. The new app might use ASP.NET Core Identity, cookie auth, OpenID Connect, OAuth, Entra ID, or JWTs for APIs. During the transition, both have to recognize the same user — which is doable with shared cookie authentication or token schemes, but it is not the place for improvisation.</p><p>Answer these early, in writing:</p><ul><li>Which app owns login during the transition?</li><li>Can both apps read the same authentication cookie?</li><li>Are cookie names, domains, paths, SameSite settings, and encryption keys aligned?</li><li>Are roles and claims equivalent on both sides?</li><li>Are authorization rules duplicated, migrated, or centralized?</li><li>What happens on logout, and when a user crosses from a new page to a legacy one?</li></ul><p>A migration can survive temporary UI inconsistency. It cannot survive broken authentication, and your users will tell you about that one immediately.</p><h3>Step 8: replace HttpModules and HttpHandlers with middleware</h3><p>The cross-cutting behavior that used to live in HttpModules — logging, auth hooks, request rewriting, error handling, correlation IDs, compression, custom headers, tenant resolution — mostly becomes middleware. A correlation-ID module, for example:</p><pre>public sealed class CorrelationIdMiddleware<br>{<br>    private readonly RequestDelegate _next;<br>    public CorrelationIdMiddleware(RequestDelegate next)<br>    {<br>        _next = next;<br>    }<br>    public async Task InvokeAsync(HttpContext context)<br>    {<br>        const string headerName = &quot;X-Correlation-ID&quot;;<br>        if (!context.Request.Headers.TryGetValue(headerName, out var correlationId))<br>        {<br>            correlationId = Guid.NewGuid().ToString(&quot;N&quot;);<br>            context.Request.Headers[headerName] = correlationId;<br>        }<br>        context.Response.Headers[headerName] = correlationId;<br>        await _next(context);<br>    }<br>}<br><br><br>app.UseMiddleware&lt;CorrelationIdMiddleware&gt;();</pre><p>Old HttpHandlers usually land as minimal API endpoints, controller actions, middleware, static file handling, or a dedicated service. The thing to preserve is the behavior, not the extension point it used to hang off of.</p><h3>Step 9: manage dependencies and shared libraries</h3><p>A migration tends to drag a dependency problem into the light. Old apps lean on .NET Framework-only libraries, ancient Entity Framework versions, packages that touch System.Web, third-party Web Forms controls, unmaintained DLLs, COM components, and assemblies someone copied into bin by hand in 2016. Each one needs a deliberate call:</p><p>Dependency type Strategy Plain C# library Move to shared project, or multi-target temporarily .NET Framework-only but replaceable Replace with a modern package System.Web dependent Isolate, then remove over time UI control library Replace in the migrated UI Database provider Upgrade or replace Internal DLL without source Treat as risk; wrap behind an interface COM / native dependency Isolate behind an adapter or a separate process</p><p>For shared business logic, multi-targeting is a useful bridge during the transition:</p><pre>&lt;TargetFrameworks&gt;net48;net10.0&lt;/TargetFrameworks&gt;</pre><p>Just don’t let the bridge become the architecture. Multi-targeting is something you pass through, not somewhere you live.</p><h3>Step 10: run both applications in production</h3><p>Incremental migration only works if you take coexistence seriously, because for a while you genuinely have two production systems. That means real clarity on deployment pipelines, rollback, logging, monitoring, health checks, authentication, routing, static files, error handling, environment config, database migrations, and who owns what operationally.</p><p>Production gets more complex before it gets simpler. That’s normal — but the complexity has to be controlled, not just tolerated. At a minimum, both apps should have separate deployment pipelines, clear versioning, health endpoints, structured logs, shared correlation IDs, error tracking, documented route ownership, and rollback instructions.</p><p>A plain migration tracker is often enough to keep everyone honest about whether the thing is actually moving:</p><p>Route Current owner Target owner Status /Customers/List.aspx Web Forms Razor Pages Planned /Orders ASP.NET Core ASP.NET Core Migrated /Reports/Monthly.aspx Web Forms Unknown Keep legacy for now /Account/Login Shared ASP.NET Core In progress</p><p>Without something like this, “the migration is going well” is a feeling, not a fact.</p><h3>Step 11: test behavior before you change structure</h3><p>Before touching a critical page, add characterization tests where you can. These don’t prove the old behavior is <em>correct</em> — they document what the system currently <em>does</em>, which is the more useful thing during a migration.</p><p>Legacy systems are full of undocumented rules. A strange conditional in some code-behind might exist because of a production incident in 2014, and if you delete it on the grounds that it looks ugly, the new system will be cleaner and wrong. Good candidates for characterization tests are the places where wrong behavior actually hurts: price calculations, order validation, import/export formats, report generation, permission checks, date and timezone handling, database mapping, integration payloads.</p><p>You don’t need to cover the whole system first — that’s its own form of procrastination. In a production migration the question isn’t “do we have enough coverage?” It’s “which tests reduce release risk?” Write those, move on.</p><h3>Step 12: decommission deliberately</h3><p>The migration isn’t finished when the new app works. It’s finished when the old one is gone — no production traffic to Web Forms, old routes removed or redirected, compatibility shims deleted, temporary multi-targeting removed, obsolete packages pulled, old deployment jobs disabled, rewrite rules simplified, monitoring consolidated, docs updated, and the team operating on the new model.</p><p>A lot of migrations skip this part. They keep the old app around <em>just in case</em>, which feels prudent and is actually how you end up running a hidden second production system for three more years. Decommissioning isn’t the cleanup after the plan. It’s part of the plan.</p><h3>A phased plan, in one screen</h3><p>If you want the step-level detail above rolled up into something you can put in front of a steering committee, it sequences into five phases:</p><ol><li><strong>Discovery and stabilization.</strong> Inventory pages, dependencies, routes, controls, and modules; identify critical flows; extract the obvious business logic from code-behind; add characterization tests for the risky bits; pick the target stack. Output: an inventory, a risk map, your first candidate pages.</li><li><strong>New .NET 10 host.</strong> Stand up the ASP.NET Core app with logging, configuration, health checks, a deployment pipeline, and the IIS-rewrite or YARP routing decided. Output: the new app running in parallel behind one internal test route.</li><li><strong>Pilot migration.</strong> Rebuild one realistic-but-not-critical page on the reused services, test the behavior, route its URL to the new app, and watch it in production. Output: a validated pattern and a validated deployment process.</li><li><strong>Module-by-module migration.</strong> Move capability in slices: migrate shared layouts and navigation, replace server controls with explicit UI, shrink session and ViewState dependence, retire each Web Forms page as it’s covered. Output: a steadily shrinking legacy surface.</li><li><strong>Decommissioning.</strong> Verify every required route is migrated, remove proxy rules and compatibility packages, simplify deployment, hand over operational ownership. Output: one application, no Web Forms runtime.</li></ol><p>The arc is the point: discovery → host → pilot → slices → cut. Each phase is allowed to be boring. Boring is what “no 18-month freeze” looks like in practice.</p><h3>The anti-patterns that sink migrations</h3><p>Most of the ways this goes wrong, I’ve seen more than once:</p><ul><li><strong>Pretending it’s a retargeting exercise.</strong> Web Forms does not run on .NET 10. Any plan that opens with “just change the target framework” isn’t a plan, it’s a wish.</li><li><strong>Starting with the hardest page.</strong> Teams want to prove value by migrating the crown-jewel workflow first. Start with a page that proves the <em>pattern</em> without betting the business on it.</li><li><strong>Rebuilding ViewState.</strong> If the new system recreates hidden server-side state everywhere, you didn’t modernize the architecture — you photocopied it.</li><li><strong>Leaving authentication until late.</strong> Auth touches every route. If both systems run side by side, it has to be designed up front, not bolted on.</li><li><strong>Treating rewrite rules as throwaway hacks.</strong> Routing rules decide production behavior. Version, review, test, and document them.</li><li><strong>Moving UI before extracting logic.</strong> Leave the business rules trapped in code-behind and every migrated page becomes a manual rewrite. Behavior first, then UI.</li></ul><h3>What’s actually specific to .NET 10 here?</h3><p>Not much — and that’s the reassuring part. The jump from Web Forms to ASP.NET Core is far bigger than the jump from .NET 9 to .NET 10. Almost none of the work is .NET 10 syntax. It’s leaving the old ASP.NET Framework model behind: System.Web, the Web Forms lifecycle, ViewState, server controls, Web.config-driven behavior, IIS-only assumptions, HttpModules and HttpHandlers.</p><p>.NET 10 just continues the modern hosting model that earlier .NET versions established. The real work is architectural: define middleware, use dependency injection, move configuration into the modern system, use endpoint routing, design state explicitly, migrate auth deliberately, isolate business logic, deploy through modern pipelines.</p><p>So if you’re already on ASP.NET Core 6, 7, 8, or 9, moving to .NET 10 is an upgrade. If you’re on Web Forms, it’s a platform migration. Those are different problems, and the second one is the one people underestimate.</p><h3>Where to start tomorrow</h3><p>A Web Forms to .NET 10 migration shouldn’t begin with a rewrite plan. It should begin with a risk plan. The path that keeps working is the unglamorous one: stabilize what exists, inventory it, extract business logic from code-behind, stand up a .NET 10 host, run both systems behind a reverse proxy, migrate one route or module at a time, and decommission the old app only when the migrated surface is complete.</p><p>That’s what “without a big rewrite” actually means. Not no rewrite. No <em>stop-the-world</em> rewrite — no 18-month freeze, no all-or-nothing cutover, just controlled modernization while the lights stay on. Legacy systems rarely get replaced safely by pretending they’re simple. They get replaced by understanding what they do, protecting what still matters, and moving responsibility into a platform the team can actually operate for the next decade.</p><p>One honest question if you’ve done one of these: what stopped your migration cold — the third-party control library, the authentication handoff, or the page nobody could explain? In my experience the blocker is almost never the framework. I’d like to hear where yours actually was.</p><p>#dotnet #aspnetcore #legacycode #softwarearchitecture #webforms</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6edb295ec350" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Characterisation testing: a safety net for legacy .NET code]]></title>
            <link>https://fries-dotnet-legacy.medium.com/characterisation-testing-a-safety-net-for-legacy-net-code-11b14a194590?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/11b14a194590</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[legacy-systems]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Mon, 08 Jun 2026 05:16:00 GMT</pubDate>
            <atom:updated>2026-06-08T05:16:00.644Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>How to pin down what your system actually does before you change a line of it.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lkp3MTYU7UDxICsp1GrfIg.png" /></figure><p>Legacy code is rarely dangerous because it’s old. It’s dangerous because nobody can say what will break when it changes.</p><p>That’s the real inheritance most teams get. Not ugly code, not dead frameworks, not the missing wiki page everyone complains about. The thing that actually slows you down is fear.</p><p>You know the shape of it. Nobody wants to touch the order calculation, because one customer has depended on a special case since 2014 and nobody remembers why. Nobody wants to change invoice generation, because the output feeds accounting, logistics, and a third-party archive, and you can’t see the blast radius from where you’re sitting. So the code sits there, working, untouched, quietly accruing more fear.</p><p>Characterisation testing is how you start touching it again. Not as a complete testing strategy. As the first net under the wire.</p><h3>It captures what the code does, not what it should do</h3><p>Characterisation testing, sometimescalled golden-master testing, has one job: capture what a system currently does. Not what it should do. Not what the product owner believes it does. What it actually does, right now, in production.</p><p>That distinction carries more weight in legacy systems than it sounds. The current behaviour is usually a sediment of years of business rules. Some were deliberate. Some crept in by accident. Some are bugs that customers have quietly built their own workflows around. Until you know which is which, every change is a gamble.</p><p>A characterisation test makes a narrow, honest claim:</p><blockquote><em>Given this input, the system currently produces this output. If that changes, I want to know.</em></blockquote><p>It says nothing about whether the behaviour is correct. It only makes the behaviour <em>visible</em>. And visible behaviour is something you can argue about, protect, refactor, or deliberately change. Invisible behaviour you can only pray over.</p><p>The term comes from Michael Feathers’ <a href="https://amzn.to/3ShAvOm"><em>Working Effectively with Legacy Code</em></a>, still the reference on this twenty years after it was published.</p><h3>Legacy .NET has a particular shape</h3><p>If you’ve worked in .NET long enough, you know these systems rarely look like the clean, constructor-injected, fast-unit-test examples in conference talks. They tend to be built out of static helpers, DateTime.Now scattered everywhere, global configuration, database state, direct file system access, stored procedures, XML and JSON exports, old ASP.NET controllers, Windows services, batch jobs, the occasional singleton, and business rules smeared across the UI, the services, and the persistence layer.</p><p>Starting with tidy unit tests in that environment isn’t realistic. You need a way to put a fence around the behaviour before you start moving the furniture. That’s the job characterisation tests do: they buy you enough confidence to begin.</p><h3>Don’t clean the code before you test it</h3><p>The most common way to start is also the most common mistake: making the code “nice” before you test it.</p><p>It sounds reasonable in the meeting. “Let’s refactor the class first, then it’ll be easy to test.” Tempting. Also backwards.</p><p>If there’s no safety net, refactoring is an educated guess with extra steps. You can improve the structure and still quietly break a rule nobody remembered was there. The safer order is the opposite of intuition:</p><ol><li>Capture the current behaviour.</li><li>Refactor behind those tests.</li><li>Replace the broad tests with focused ones where it helps.</li><li>Only then change behaviour on purpose.</li></ol><p>In a legacy system, tests aren’t only a quality tool. They’re how you learn what the thing does.</p><h3>How I actually start</h3><p>Here’s the workflow I reach for in front of untested legacy .NET.</p><h4>Pick a narrow slice</h4><p>Don’t start with “test the system.” Start with one behaviour you need to change: a price calculation, an invoice export, a validation rule, an API response, a scheduled job that writes a file.</p><p>The slice should be small enough to exercise and important enough that breaking it would hurt. The rule I keep in my head is to test around the area I’m about to touch, not the area that looks easiest to test.</p><h4>Get the code into a harness</h4><p>Your first test will probably be ugly. Fine. You’re not after elegance yet, you’re after access — proof that you can call the existing code path from a test and see what comes back.</p><pre>[Fact]<br>public void GenerateInvoice_ExistingCustomer_ProducesCurrentOutput()<br>{<br>    var service = new InvoiceExportService();<br>    var result = service.GenerateInvoice(customerId: 123, month: 5, year: 2026);<br>    Assert.NotNull(result);<br>}</pre><p>This protects almost nothing. But it proves the one thing that matters at the start: the code can run from a test. That’s your first seam.</p><h4>Let the system tell you what it does</h4><p>Feathers’ move here is deliberately dumb. Write an assertion, let it fail, read the actual behaviour off the failure, then write that down as the test.</p><pre>[Fact]<br>public void CalculateDiscount_ForLegacyCustomer_ReturnsCurrentDiscount()<br>{<br>    var service = new DiscountService();<br>    var discount = service.CalculateDiscount(<br>        customerType: &quot;Legacy&quot;,<br>        orderValue: 10_000m,<br>        contractStart: new DateTime(2016, 1, 1));<br>    Assert.Equal(0m, discount);<br>}</pre><p>Say this fails because the real result is 0.075m. Good, you just learned something the code wasn&#39;t telling you. So you update the assertion:</p><pre>Assert.Equal(0.075m, discount);</pre><p>That 7.5% isn’t necessarily correct. It’s just current. But now it’s pinned down, and a future change can’t move it without you noticing.</p><h4>Cover the cases you’re actually afraid of</h4><p>One test is rarely enough. Add cases around the behaviour you want to protect: the normal path, the boundaries, an old customer and a new one, missing optional data, invalid input, culture-specific formatting, the weird tax case, the empty result, the large data set.</p><p>Don’t chase perfect coverage. The question isn’t “did we test everything?” It’s “would these tests catch the kind of regression that keeps me up at night?”</p><h4>Use golden masters for big outputs</h4><p>Some behaviours are miserable to assert by hand: JSON and XML payloads, generated CSVs, rendered HTML, log output, PDF metadata, serialized messages. For those, snapshot or golden-master testing beats writing a hundred tiny assertions.</p><pre>[Fact]<br>public async Task ExportOrder_CurrentBehaviour_MatchesApprovedSnapshot()<br>{<br>    var service = CreateLegacyOrderExportService()<br>    var json = service.ExportOrder(orderId: 4711);<br>    var normalized = JsonNormalizer.Normalize(json);<br>    await Verify(normalized);<br>}</pre><p>The first run produces a received output. You read it, and if it’s a fair picture of current behaviour, you approve it as the baseline. After that, any change to the output fails the test.</p><p>That’s powerful, and it’s also where discipline comes in. A snapshot test must never decay into an “approve all” button. When it goes red, the team has exactly one question to answer: did we mean to change this? If yes, update the snapshot. If no, fix the code. The moment you start approving diffs you haven’t read, the net has a hole in it.</p><h3>A concrete example: the invoice file service</h3><p>Picture a legacy service that builds an invoice as JSON and writes it to disk.</p><pre>public class InvoiceFileService<br>{<br>    public string CreateInvoiceFile(int invoiceId)<br>    {<br>        var invoice = InvoiceRepository.Load(invoiceId);<br>        invoice.GeneratedAt = DateTime.Now;<br>        invoice.TaxRate = TaxRules.CurrentRate();<br>        var json = JsonConvert.SerializeObject(invoice, Formatting.Indented);<br>        var path = @&quot;C:\Exports\Invoices\&quot; + invoice.Number + &quot;.json&quot;;<br>        File.WriteAllText(path, json);<br>        return path;<br>    }<br>}</pre><p>You can see why this is hard to test at a glance: it reaches into the database, the current time, a static tax rule, JSON formatting, a hardcoded path, and the real file system, all in one method. A full rewrite would be a gamble. So you start smaller.</p><h4>The first, ugly test</h4><p>Run the current code against a known test database and check the file it writes.</p><pre>[Fact]<br>public void CreateInvoiceFile_ForKnownInvoice_WritesCurrentJson()<br>{<br>    var service = new InvoiceFileService();<br>    var path = service.CreateInvoiceFile(1001);<br>    var json = File.ReadAllText(path);<br>    Assert.Contains(&quot;\&quot;Number\&quot;: \&quot;INV-1001\&quot;&quot;, json);<br>}</pre><p>Not beautiful, not the final design. But it’s your first grip on the system.</p><h4>Make the output deterministic</h4><p>That test will flake, because DateTime.Now changes on every run. So you introduce a seam. Not a redesign, just a thin wrapper.</p><pre>public interface IClock<br>{<br>    DateTime Now { get; }<br>}<br>public sealed class SystemClock : IClock<br>{<br>    public DateTime Now =&gt; DateTime.Now;<br>}</pre><p>The service takes the clock:</p><pre>public class InvoiceFileService<br>{<br>    private readonly IClock _clock;<br>    public InvoiceFileService(IClock clock)<br>    {<br>        _clock = clock;<br>    }<br>    <br>    public string CreateInvoiceFile(int invoiceId)<br>    {<br>        var invoice = InvoiceRepository.Load(invoiceId);<br>        invoice.GeneratedAt = _clock.Now;<br>        invoice.TaxRate = TaxRules.CurrentRate();<br>        var json = JsonConvert.SerializeObject(invoice, Formatting.Indented);<br>        var path = @&quot;C:\Exports\Invoices\&quot; + invoice.Number + &quot;.json&quot;;<br>        File.WriteAllText(path, json);<br>        return path;<br>    }<br>}</pre><p>Now the test can freeze time:</p><pre>private sealed class FixedClock : IClock<br>{<br>    public DateTime Now =&gt; new(2026, 5, 1, 10, 0, 0);<br>}<br><br>[Fact]<br>public async Task CreateInvoiceFile_ForKnownInvoice_MatchesCurrentSnapshot()<br>{<br>    var service = new InvoiceFileService(new FixedClock());<br>    var path = service.CreateInvoiceFile(1001);<br>    var json = File.ReadAllText(path);<br>    var normalized = JsonNormalizer.Normalize(json);<br>    await Verify(normalized);<br>}</pre><p>You haven’t fixed the design. You’ve removed one source of randomness. That’s progress you can build on.</p><h4>Then take the next dependency</h4><p>With time under control, move to the static tax rule.</p><pre>public interface ITaxRules<br>{<br>    decimal CurrentRate();<br>}<br>public sealed class TaxRulesAdapter : ITaxRules<br>{<br>    public decimal CurrentRate() =&gt; TaxRules.CurrentRate();<br>}</pre><p>Inject it the same way:</p><pre>public class InvoiceFileService<br>{<br>    private readonly IClock _clock;<br>    private readonly ITaxRules _taxRules;<br>    <br>    public InvoiceFileService(IClock clock, ITaxRules taxRules)<br>    {<br>        _clock = clock;<br>        _taxRules = taxRules;<br>    }<br>    <br>    public string CreateInvoiceFile(int invoiceId)<br>    {<br>        var invoice = InvoiceRepository.Load(invoiceId);<br>        invoice.GeneratedAt = _clock.Now;<br>        invoice.TaxRate = _taxRules.CurrentRate();<br>        var json = JsonConvert.SerializeObject(invoice, Formatting.Indented);<br>        var path = @&quot;C:\Exports\Invoices\&quot; + invoice.Number + &quot;.json&quot;;<br>        File.WriteAllText(path, json);<br>        return path;<br>    }<br>}</pre><p>The rhythm is always the same: capture behaviour, introduce a seam, keep the tests green, repeat. That loop is how you refactor legacy code without gambling on it.</p><h3>Where they earn their keep</h3><p>Characterisation tests are most valuable exactly when you feel most exposed. Nobody fully understands the code. The behaviour is undocumented. A rewrite is too risky. There are too many dependencies to mock cleanly. The output is large or structured. The business rules are buried in nested conditionals, and the team needs confidence before it dares refactor anything.</p><p>They also change the politics, which I didn’t expect the first time I leaned on them. A failing characterisation test turns a meeting argument into a factual one. Instead of debating whether someone broke something, you point at the diff and ask, “this output changed, was that on purpose?” That’s a much better conversation to be having.</p><h3>What they won’t do for you</h3><p>Characterisation tests aren’t magic, and it’s worth being blunt about the limits. They don’t prove the system is correct. They don’t replace understanding the domain. They won’t tell you which behaviour deserves to survive, and they don’t remove the need for proper unit tests later. They buy you the room to write those.</p><p>They can also turn noisy. If the output contains timestamps, generated IDs, absolute paths, environment or machine names, random ordering, or culture-dependent date and number formatting, the test will fail for reasons that have nothing to do with your change. Normalise that out before you approve a golden master. A flaky characterisation test is worse than none at all, because it trains the team to ignore red, and a net everyone ignores isn’t a net.</p><h3>Wrap first, inject second, split later</h3><p>When you’re dealing with static state, resist the urge to redesign everything in one pass. Start with a thin wrapper.</p><pre>public interface ISystemSettings<br>{<br>    string Get(string key);<br>}<br><br>public sealed class SystemSettingsAdapter : ISystemSettings<br>{<br>    public string Get(string key) =&gt; LegacySettings.Get(key);<br>}</pre><p>Then replace the direct calls one consumer at a time, and only split the interface later if it grows too broad. Small, reversible steps. The goal isn’t a perfect abstraction on day one. It’s enough testability to keep going safely.</p><h3>These tests are scaffolding, not the building</h3><p>A characterisation test is usually temporary. It keeps you safe while the system is still murky, but once the design improves, it’s worth asking whether the broad test is still the right tool.</p><p>A snapshot around a full invoice export might stay useful as a regression guard. A broad test around a calculation service is often better replaced by focused unit tests once you understand the logic. An integration-heavy test might get too slow for every commit and move to a nightly run. A brittle golden master can give way to semantic assertions once the domain rules are clear.</p><p>The maturity path tends to run like this: a characterisation test around current behaviour, refactoring under its protection, smaller unit tests around the logic you extract, integration tests around the critical workflows, then retiring or shrinking the broad snapshots. Characterisation testing is the entrance, not the destination.</p><h3>How to sell this to a tired team</h3><p>Don’t open with a testing crusade. Developers are worn out from being told the legacy system needs “more tests.” They know. What they don’t have is a way to start without rewriting everything.</p><p>So start with one risky change. Pick the area people are most afraid to touch and say: before we change it, let’s capture what it currently does. That framing does most of the persuading for you.</p><p>A realistic first goal is small on purpose: one code path, one test harness, five to ten representative cases, one documented decision about which behaviour is intentional, and one small refactoring with the tests staying green. That’s enough to build momentum, and momentum is the thing that actually changes how a team works.</p><h3>The real payoff isn’t the test</h3><p>The biggest benefit of characterisation testing isn’t the test file. It’s the change in how it feels to touch the code.</p><p>Before, a legacy change comes with a shrug: “I think this should be safe.” After, it comes with evidence: “we changed the structure, and the observed behaviour stayed the same.” That’s a different level of confidence, and you can feel it in how fast a team moves.</p><p>It doesn’t make legacy code easy. Nothing does. But it makes it workable, and in most legacy .NET systems that’s what you need first. Not a rewrite, not a grand architecture vision. A net under the wire, then the nerve to improve the system one seam at a time.</p><p>If you’ve pulled a legacy .NET system out of the fear zone, I’d like to know what you reached for first to pin the behaviour down: handwritten assertions, a snapshot library like Verify or ApprovalTests, something else entirely? The before-the-refactor part is where I see teams get stuck most often.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11b14a194590" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Rewriting Legacy Code and Start Measuring]]></title>
            <link>https://fries-dotnet-legacy.medium.com/stop-rewriting-legacy-code-and-start-measuring-a41665feaa34?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a41665feaa34</guid>
            <category><![CDATA[legacy-code]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[career-advice]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Mon, 01 Jun 2026 06:21:00 GMT</pubDate>
            <atom:updated>2026-06-01T06:21:00.612Z</atom:updated>
            <content:encoded><![CDATA[<h4>The first instinct is always the same.</h4><p>You inherit a codebase. It’s old. It smells. Half the comments are lies, the other half are contradictions. Somewhere in there is a module nobody touches because the one developer who understood it left in 2019. Your first thought — and I know this because I’ve had it dozens of times — is: let’s start over.</p><p>That instinct will cost you months. Possibly years.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D2lHvrwW-8eWSLV8xURwCQ.png" /></figure><h3><strong>The Rewrite Fantasy</strong></h3><p>Legacy systems aren’t just old code. They’re accumulated business rules, operational quirks, and hard-won workarounds that nobody fully documented because everyone was too busy keeping the line running.</p><p>I’ve seen this in manufacturing environments where a .NET application from 2007 quietly calculated OEE metrics with a formula nobody questioned — until someone tried to replace it and discovered the “wrong” formula was actually correct for that specific production setup. The system wasn’t broken. It was encoding institutional knowledge nobody had bothered to write down.</p><p>Rewriting first and understanding second is the fast way of loosing time, money and nerves.</p><h3><strong>The codebase is already telling you where it hurts</strong></h3><p>A 2023 study by Li, Soliman, and Avgeriou showed something I found genuinely useful: <strong>self-admitted technical debt </strong>— the kind developers flag in comments, commit messages, issues, and pull requests — can be systematically identified and clustered across all four of those sources. Automatically.</p><p>That’s not theoretical and it only takes a few hours, not months.</p><p>In practice: extract all TODO, FIXME, HACK, and XXX comments. Parse commit messages that mention workarounds or “temporary” solutions. Cross-reference with your issue tracker for recurring bug clusters. Suddenly you’re not staring at 400,000 lines of equal mystery — you’re looking at a map with three or four clearly marked danger zones.</p><p>Security debt deserves its own pass here. Coetzer and Leenen (2024) showed that security vulnerabilities in legacy systems respond to the same identification logic — and carry disproportionate risk. A ten-year-old authentication module with known vulnerability patterns is not the same problem as a slightly outdated ORM. Getting that distinction wrong isn’t a refactoring headache. It’s a breach.</p><h3><strong>Fix things in slices, not in chapters</strong></h3><p>Once you know what matters, the temptation shifts. Now you want to fix everything you measured. Resist that too.</p><p>The strongest pattern I’ve seen — one that Lano et al. (2024) describe formally — is to <strong>abstract first, then refactor, then regenerate.</strong> Build a model of the system’s current behavior. Rearchitect at the model level. Translate back to code. Verify semantic equivalence with tests and runtime checks at each step.</p><p>On a Monday morning, this means: you don’t rewrite the invoice calculation module. You write characterization tests around it — tests that document what it currently does, not what it should do. Then you refactor in small slices, running those tests after each change. If something breaks, you know exactly where and why.</p><p>The goal isn’t a cleaner codebase. It’s a codebase that behaves identically but is easier to change — and you can only verify that if you have the tests to prove it.</p><h3><strong>The business rules are not in the code</strong></h3><p>This is the one that bites people hardest.</p><p>Legacy systems in manufacturing, finance, and logistics encode decades of domain logic and most of it lives in the heads of people who’ve been working with the system for fifteen years. To them it’s not knowledge, it’s just how things work. They don’t think to mention it until you break it.</p><p>You cannot safely change what you don’t understand, and you cannot understand it from the code alone.</p><p>Before any significant refactoring session, talk to the domain expert. What does this calculation actually represent? When does this edge case apply? Why does the system behave differently on the last working day of the month? These aren’t pleasant conversations to schedule. They’re the actual work.</p><p>The code isn’t the specification. It’s a snapshot. And snapshots decay.</p><h3><strong>Where AI tooling actually helps</strong></h3><p>AI-assisted modernization is real and useful. Annela (2025) documents meaningful gains across the full pipeline — system assessment, migration planning, code transformation, testing, and integration.</p><p>But there’s a version of this that goes wrong fast. You point a tool at a legacy codebase, ask it to modernize, and trust the output because the tests pass. Tests written by the same tool that generated the transformation aren’t independent verification. They’re circular validation.</p><p>The honest version is narrower: automation removes repetitive analysis and transformation work. Let it scan for dead code. Let it flag coupling hotspots. Let it generate initial characterization test scaffolding. Use it to accelerate the measurement phase and not replace it.</p><p>Every meaningful architectural decision still requires someone who understands both the business domain and the system’s behavior. That judgment doesn’t automate away.</p><h3><strong>Where to start</strong></h3><p>Most teams don’t need a grand modernization plan. Three things you can do without executive approval:</p><p>Run a comment miner against your git history. Open-source tools parse source comments and commit messages for self-admitted technical debt. The output will surprise you.</p><p>Pick your highest-risk file — the one your team mentions in hushed tones — and add characterization tests until you understand what it actually does. Don’t change anything yet.</p><p>Find the domain expert who has worked with this system the longest and ask what the code misrepresents about the actual business process. Not what it breaks. What it gets subtly wrong. That conversation is worth more than any static analysis tool.</p><p>The systems that got successfully modernized weren’t the ones that got rewritten fastest. They were the ones where someone slowed down, measured the actual risk, understood the embedded business rules, and moved in small, verified steps.</p><p><em>References:</em> <em>Li, Y., Soliman, M., &amp; Avgeriou, P. (2023). Automatic identification of self-admitted technical debt from four different sources. Empirical Software Engineering, 28(3). </em><a href="https://doi.org/10.1007/s10664-023-10297-9"><em>https://doi.org/10.1007/s10664-023-10297-9</em></a> <em>Coetzer, C. &amp; Leenen, L. (2024). Managing Cyber Security Debt. ICCWS, 19(1), 439–446. </em><a href="https://doi.org/10.34190/iccws.19.1.2178"><em>https://doi.org/10.34190/iccws.19.1.2178</em></a> <em>Lano, K. et al. (2024). Agile model-driven re-engineering. Innovations in Systems and Software Engineering, 20(4), 559–584. </em><a href="https://doi.org/10.1007/s11334-024-00568-z"><em>https://doi.org/10.1007/s11334-024-00568-z</em></a> <em>Annela, L. (2025). AI-Augmented Legacy Modernization. JCSTS, 7(5), 119–128. </em><a href="https://doi.org/10.32996/jcsts.2025.7.5.16"><em>https://doi.org/10.32996/jcsts.2025.7.5.16</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a41665feaa34" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vibe Coding is Legacy in Realt-Time]]></title>
            <link>https://fries-dotnet-legacy.medium.com/vibe-coding-is-legacy-in-realt-time-6fcff6ad089e?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/6fcff6ad089e</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Mon, 25 May 2026 06:31:00 GMT</pubDate>
            <atom:updated>2026-05-25T06:31:00.498Z</atom:updated>
            <content:encoded><![CDATA[<h4>AI didn’t slow down the legacy code problem. It gave it a turbo boost.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CABcpGf18H-coauow8jlEQ.png" /></figure><p>Legacy code used to take years to grow, but with AI, you can create it in a sprint.</p><p>For years, technical debt accumulated at a pace teams could naturally manage. Features took time to build, reviews took time to complete, and every architectural shortcut carried some cognitive resistance because someone eventually had to sit down and implement the details by hand. That process was imperfect, but it created moments where engineers were forced to think through assumptions, edge cases, and trade-offs before code reached production. Decisions made in a hurry still made code worse over time, new features bolted onto existing structures, cleanup perpetually postponed, but the growth was slow enough that teams could usually keep up with it.</p><p>Today, one developer can describe a feature in a few sentences and receive hundreds of lines of production-looking implementation within minutes. The productivity gain is real, but so is the hidden cost. The challenge was never how quickly software could be written. It has always been whether a team still understands the system well enough to safely change it later — and AI generation doesn’t solve that problem. In many cases, it quietly amplifies it.</p><h3>Legacy Is Not Old Code</h3><p>The industry talks about legacy code as if age were the defining characteristic. Age has very little to do with it.</p><p>Some of the healthiest systems I’ve worked on were more than a decade old because their boundaries were clear, their assumptions were documented, and ownership remained visible across the organization. At the same time, I’ve seen projects become effectively untouchable within months because the team no longer understood why certain decisions had been made or what risks were hidden behind seemingly simple changes.</p><p>That distinction matters now more than ever because AI-generated systems can appear mature long before they are actually maintainable.</p><p><strong><em>Legacy code is not old code. Legacy code is code nobody feels safe changing.</em></strong></p><p>Michael Feathers famously defined it more precisely: l<em>egacy code is code without tests</em>. That definition is useful, but it doesn’t go far enough. Code with tests can still be impossible to maintain if nobody understands what those tests protect, how they are structured, or how they should be extended when requirements change. A system with 99% coverage can still make every release feel like a gamble.</p><p>Other definitions describe symptoms rather than causes. Long-lived systems built on outdated technology, high maintenance effort, accumulated technical debt — these are all real, but they are what legacy looks like from the outside, not what produces it. A badly structured application does not stop being legacy because it has been migrated from .NET Framework to .NET 8. It may simply become the same problem in newer packaging.</p><p>What actually makes a system legacy is more subtle. It happens when the relationship between change risk, change effort, and organizational knowledge loss exceeds the team’s ability to evolve the system safely. And it rarely happens because of one bad decision. It accumulates through many small ones made under pressure: shortcuts taken for delivery, cleanup postponed indefinitely, knowledge left undocumented because there was never a right moment, complexity accepted because there was no time to challenge it. Over time, those decisions compound until the system still runs — but can no longer be changed with confidence.</p><p>Legacy, in other words, is not an attribute of the code alone. It is a condition that exists in the relationship between the system, the team, and the business requirements placed on it. A better definition of legacy code should then be this:</p><blockquote>A legacy system is a software system in which accumulated entropy, caused by unaddressed measures, implicit knowledge, and the absence of structural counterforces, has increased the risk and effort of change to a point where they exceed the organization’s ability to evolve. Legacy, therefore, is not an attribute of the code alone, but a condition that exists in the relationship between system, team, and business requirements.</blockquote><h3>The CSV Import That Shipped in 20 Minutes and Broke for Months</h3><p>Lets discuss that in a real example.</p><p>A team needs a customer CSV import feature. A developer opens an AI coding assistant, asks for a complete import service, and within half an hour has parsing logic, validation flows, database mapping, retry handling, background jobs, logging, and automated tests. The feature demos successfully, the pull request looks clean, and the system ships faster than the team expected.</p><p>Three months later, the problems surface.</p><p>Customers upload malformed files the original implementation never anticipated. Validation rules evolve after new business requirements appear, but nobody remembers where those rules actually live in the generated logic. Duplicate imports occasionally create inconsistent records because idempotency was never explicitly discussed. Retry behavior starts masking infrastructure issues instead of exposing them, while the logs produce enough noise to overwhelm anyone trying to diagnose failures. The unit tests still pass, but they mostly confirm that the implementation behaves consistently with itself, not that the business behavior is still correct.</p><p>The code is three months old. It is already legacy.</p><p><strong><em>The code was generated in minutes. The uncertainty was generated with it.</em></strong></p><p>This is not a story about AI failing. The model did exactly what it was asked. The problem is that nobody defined what “correct” meant before the prompt was sent.</p><h3>Why AI Accelerates This Specific Failure Mode</h3><p>Manual implementation had a natural forcing function: the slowness of typing forced decisions.</p><p>When you write a CSV parser by hand, you hit moments of genuine friction. What should happen when a row is missing a required field? You have to decide. You write that decision into the code, maybe add a comment, maybe write a test for the edge case. You find yourself in existing code where you need to adapt or change methods. The friction forces clarity.</p><p>AI removes the friction. Which sounds like progress until you realize the friction was doing real work.</p><p>If you don’t define where the boundary is before prompting, the model invents one. If you don’t specify the retry policy, it picks something that looks reasonable. If you don’t separate infrastructure concerns from domain validation rules, they become intertwined inside generated abstractions that nobody fully owns afterward. The result is functional software built on undocumented decisions the team never consciously reviewed.</p><p><strong><em>That is why the most important engineering work now happens before code generation starts, not after it finishes.</em></strong></p><h3>Force a Design Discussion Before Any Code Exists</h3><p>Teams that use AI effectively tend to approach prompts less like implementation requests and more like architectural conversations. Instead of immediately asking for a completed feature, they force trade-offs to the surface first because the moment you generate implementation code without a design decision behind it, you’re not saving time. You’re just postponing the conversation until it’s far more expensive to have.</p><p>The prompt you send sets the scope of the answer you get. A vague implementation request returns vague implementation. A precise architectural question returns something you can actually review, challenge, and decide on together as a team.</p><p>Bad prompt:</p><pre>Build a CSV import service for customer data.</pre><p>Better prompt:</p><pre>You are a senior .NET architect with deep experience designing data ingestion pipelines for production systems using Clean Architecture and Domain-Driven Design principles.<br><br>I need you to propose three distinct implementation approaches for a CSV customer import feature in a .NET 8 Worker Service or Console App. These should represent meaningfully different architectural choices — not variations on the same pattern. The import will handle medium-sized files (1,000–50,000 rows, regular uploads).<br><br>For each approach, cover:<br><br>- **Testability**: How easily can the logic be unit tested and integration tested? What&#39;s awkward or hard to isolate?<br>- **Failure handling**: How does it behave when rows are malformed, validation fails, or partial imports occur? Can it recover gracefully or report per-row errors?<br>- **Transaction safety**: How does it protect against partial writes, duplicate imports, or data corruption if the process is interrupted?<br>- **Long-term maintainability**: How does it hold up as requirements evolve — new columns, new validation rules, higher import volumes, new file sources?<br><br>Close with a direct recommendation on which approach fits best for a standard production scenario, and flag any conditions that would change that recommendation.<br><br>Do not write code. Focus entirely on architecture, trade-offs, and decision criteria. Structure your analysis around use cases and domain layers as they apply to each approach.</pre><p>That shift changes the dynamic entirely because the conversation becomes about decisions rather than output volume. Ownership is established through decision-making, not through code generation. If you skip the design conversation and go straight to implementation, you get code that works, but a team that doesn’t fully understand why it works the way it does, and won’t know what’s safe to change when requirements shift three months later.</p><h3>Make Assumptions Visible Before They Become Risks</h3><p>Every generated implementation sits on an invisible set of expectations about input quality, transaction behavior, retries, validation rules, and failure handling. If those assumptions remain implicit, they become future maintenance incidents.</p><p>Add this to your prompt before implementation begins:</p><pre>You are a technical architect reviewing implementation requirements. Your task is to identify and document all assumptions that must be validated before writing code.<br><br>For the implementation being planned, systematically list every assumption across these categories:<br><br>**Input Format**<br>What data structure, schema, or format is expected? What encoding, encoding variants, or field types? Are there size limits, character restrictions, or structural constraints? What happens with empty, null, or malformed inputs?<br><br>**Validation Rules**<br>What checks must pass before processing? Which fields are required versus optional? What are the acceptable value ranges, formats, or patterns? Should validation happen synchronously or asynchronously? What triggers a validation failure, and how is it communicated?<br><br>**Idempotency**<br>Can this operation be executed multiple times with identical inputs and produce the same result? If yes, what makes it idempotent—deduplication logic, state checking, or something else? If no, what prevents it and why is that acceptable?<br><br>**Transaction Handling**<br>Does this operation span multiple systems or databases? If it fails partway through, what rolls back and what stays? Is all-or-nothing behavior required, or are partial successes acceptable? How are in-flight transactions tracked?<br><br>**Error Logging**<br>What gets logged when things fail? Should logs include input data, stack traces, correlation IDs, or user context? How much detail is stored without creating security or compliance risks? Where do logs go—stdout, files, external system?<br><br>**Retry Behavior**<br>Should failed operations be retried automatically? If yes, how many times and with what delay between attempts? Are some errors retryable while others are fatal? How does retry logic interact with idempotency?<br><br>For each category, state the assumption clearly, then note whether it&#39;s been confirmed with stakeholders or is still uncertain. Flag any assumptions that block implementation decisions.</pre><p>Then treat that list like code. Review it. Challenge it. If an assumption encodes business behavior, imports must be idempotent, invalid rows are skipped but logged, retries only apply to transient database errors. A human needs to explicitly approve it before any implementation starts.</p><p><strong><em>Assumptions that affect business behavior are not implementation details. They are requirements. The difference is that requirements get reviewed and assumptions don’t.</em></strong></p><h3>Test Business Behavior, Not Generated Structure</h3><p>AI-generated tests have a consistent flaw: they look comprehensive because coverage numbers are high, but many of them simply mirror the generated implementation instead of validating business behavior independently.</p><p>This happens because the model writes tests the same way it writes code by looking at what already exists and producing something consistent with it. Ask AI to generate tests after it has generated the implementation, and you get a test suite that confirms the internal logic of that specific implementation. Which means the tests tell you nothing useful when the business rules change. They would only fail if the code structure changed, not if the behavior became wrong.</p><p><strong><em>Coverage is not confidence.</em></strong></p><p>The most reliable way to avoid this is to write the behavior tests yourself before generating any implementation. Not because AI cannot write tests, but because the act of writing them forces you to think through the requirements independently of whatever the implementation might look like. When you write a test for malformed input before any code exists, you’re making a decision about expected behavior. When AI writes that same test after generating the code, it’s making an observation about current behavior. Those two things are not the same.</p><p>If you do use AI for test generation, give it requirements, not code:</p><pre>You are a test engineer writing behavior-focused test cases for a CSV import system. Your task is to write tests that verify observable system behavior—what users and downstream systems experience—rather than testing internal implementation details like private methods, class structure, or internal state.<br><br>**Your test coverage must include:**<br><br>1. **Malformed files** - Tests that verify the system gracefully handles invalid CSV structure (missing headers, inconsistent column counts, invalid formatting). Confirm appropriate error messages or rejection behavior.<br><br>2. **Duplicate rows** - Tests that verify how the system handles identical records appearing multiple times in a single import. Confirm the intended deduplication behavior.<br><br>3. **Missing required fields** - Tests that verify the system rejects or handles records missing critical data (e.g., customer name, email). Confirm which fields trigger rejection and what feedback is provided.<br><br>4. **Invalid customer IDs** - Tests that verify the system rejects records with customer IDs that don&#39;t exist in the system or fail validation rules. Confirm the error handling and user feedback.<br><br>5. **Retry behavior** - Tests that verify the system handles transient failures appropriately. If an import fails partway through, confirm retry logic works correctly and doesn&#39;t corrupt state.<br><br>6. **Idempotency** - Tests that verify running the same import twice produces the same result (no duplicate records created, no data corruption). Confirm that re-running a successful import is safe.<br><br>**Write tests from the outside in.** Focus on what a user or API consumer would observe: Does the import succeed or fail? What records actually made it into the system? What errors were reported? Don&#39;t test private methods, mock internal objects, or verify how the code accomplishes the work internally.<br><br>Use clear test names that describe the scenario and expected outcome. Arrange tests so someone reading them understands the import system&#39;s behavior without needing to read the implementation.</pre><p>The real value of tests is not proving that code executes consistently with itself. It is proving that the system still behaves correctly when requirements change, which they always will, usually at the worst possible moment.</p><h3>Attach Context to Every Generated Module</h3><p>Generated code loses context faster than hand-written code because there’s no slow deliberation trail behind it. A simple ownership note at the top of a module. Which team owns the business rules, which assumptions are intentional, which operational constraints apply may seem unnecessary during implementation, but six months later it often becomes the difference between confident iteration and painful reverse engineering.</p><pre>Ownership note:<br>This module handles CSV customer imports.<br>Business rules owned by: Customer Operations team.<br>Technical ownership: Platform team.</pre><pre>Known assumptions:<br>- Imports must be idempotent by externalCustomerId + importBatchId.<br>- Invalid rows are skipped but reported.<br>- Database writes happen in batches of 500.<br>- Retry is only allowed for transient database errors.</pre><p>Without that context, new engineers become archaeologists reconstructing intent from generated abstractions. With it, they can reason about changes and move forward without fear.</p><h3>Review for Failure Modes, Not for Style</h3><p>This is where most AI-assisted code reviews go wrong.</p><p>Generated code is often stylistically clean. Consistent naming, reasonable abstractions, polished formatting. But maintainability is rarely destroyed by formatting problems. It is destroyed by hidden failure modes, unclear ownership boundaries, and assumptions that nobody notices until production traffic exposes them.</p><p>The questions that actually matter in review:</p><ul><li>What happens under partial failure?</li><li>What happens if this runs twice?</li><li>What happens when input is larger than expected?</li><li>Can we observe failures in logs or metrics?</li><li>Is the business rule visible, or buried inside generic code?</li><li>Can we safely change this in six months?</li></ul><p><strong><em>Formatting generated code is not engineering. Understanding its failure modes is.</em></strong></p><p>If your review doesn’t touch those questions, you haven’t reviewed the code. You’ve given it a cosmetic inspection and moved on.</p><h3>The Metric That Actually Matters</h3><p>The real value of AI is not measured by how many lines of code it generates or how quickly features reach production. Those metrics are easy to optimize and easy to celebrate, but they say very little about the long-term health of a system.</p><p>The more meaningful question is whether the team can still understand and safely evolve the software six months after the original prompt has been forgotten. Teams that preserve clarity, ownership, and explicit decision-making while using AI will almost certainly outperform teams that optimize purely for generation speed. Not in week one, but in month six when the first major refactoring becomes necessary.</p><p>The organizations that struggle won’t necessarily be the ones producing bad code. More often, they’ll be the ones producing code faster than their understanding can keep up with it.</p><p>After 17 years in production-critical environments, I’ve seen the same pattern repeat itself with different tools and different teams. Most legacy systems didn’t begin as engineering catastrophes. They began as useful software built under time pressure, with assumptions that seemed obvious in the moment and documentation that felt unnecessary while the original authors were still around. Over time, teams changed, requirements evolved, and the context surrounding those decisions quietly disappeared.</p><p>AI accelerates that exact process. The teams that benefit most won’t be the ones generating the highest volume of code. They’ll be the ones disciplined enough to preserve understanding while moving faster.</p><p>Before using AI to generate any significant implementation, require three things: a clear <strong>boundary</strong> defining what the module owns, an explicit list of <strong>assumptions</strong> reviewed like production code, and <strong>behavior tests</strong> written against requirements rather than against the generated structure.</p><p>If those three things are missing, you are not accelerating engineering. You are just creating legacy code faster.</p><blockquote><em>The question is not whether AI can write the code. The question is whether your team can still own it after the prompt is forgotten.</em></blockquote><p>Because shipping fast and shipping maintainably are not opposites. But they do require different habits.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6fcff6ad089e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CI/CD Is Not a Developer Toy. It’s Production Safety.]]></title>
            <link>https://fries-dotnet-legacy.medium.com/ci-cd-is-not-a-developer-toy-its-production-safety-8b5fc73f2432?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b5fc73f2432</guid>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[manufacturing-technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[legacy-systems]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Mon, 18 May 2026 06:01:01 GMT</pubDate>
            <atom:updated>2026-05-18T06:01:01.534Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why every Industry 4.0 initiative without stable deployment pipelines is a time bomb</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YaLzN7S3UyUDxlj7i2p0lA.png" /></figure><p>Friday, 10:47 PM. The production line is down. Not because of a machine failure, not because of a material shortage. Because someone pushed a hotfix to the MES during day shift, the deployment was done manually via Remote Desktop, and nobody can tell you exactly what changed or how to get back to a known state.</p><p>I’ve been in that room. The silence when OEE drops to zero. The frantic Slack messages. The engineer who “knows the system” getting pulled off his weekend.</p><p>Before you connect your assets, before you publish Digital Product Passports, before you implement OPC UA across your shop floor — you need to be able to deploy your software without it being a crisis. Not an event. Not a heroic act. A routine.</p><p>Most Industry 4.0 roadmaps skip this entirely. That’s the problem.</p><h3>The Most Dangerous Sentence in Manufacturing IT</h3><blockquote>“Never touch a running system.”</blockquote><p>I understand where it comes from. In brownfield environments, especially production-critical infrastructure, the fear is real. You change one config file on a gateway and suddenly the SCADA can’t read from three PLCs. You patch a legacy MES module and lose two hours of shift data.</p><p>But what that sentence actually means in practice: every avoided change becomes deferred risk, and deferred risk compounds. Patches don’t get applied. Security vulnerabilities stay open. New regulatory requirements — like the EU Digital Product Passport, which will mandate specific data fields across entire supply chains — get bolted on top of already fragile integrations.</p><p>The longer you don’t touch it, the worse the eventual touch will be.</p><p>I’ve seen it firsthand. Industrial .NET environments running on Windows 7. Proprietary SPC systems that nobody remembers how to modify. They feel stable. They’re not. They’re dormant failures waiting for a deadline or an audit to surface them.</p><p><em>Stability that comes from inaction is not stability. It’s accumulated risk wearing a calm face.</em></p><h3>“Stable” and “Under Control” Are Not the Same Thing</h3><p>Most industrial software systems I work with are stable in one specific sense: they’re currently running. Very few are genuinely under control.</p><p>The difference shows up the moment something goes wrong. In a system you actually control, you roll back. In a “stable” one, you call the one person who set it up six years ago and hope he picks up on a Saturday.</p><p>That’s the real fragility — knowledge that lives in someone’s head instead of in version-controlled code, pipeline definitions, and documented runbooks. OT security specialists have a name for it: a truck number of 1. One person gets hit by a bus (or takes a holiday) and your system becomes functionally untouchable.</p><p><em>A system is only as controllable as its worst documented process.</em></p><p>For industrial software, that process is almost always deployment.</p><h3>Frequent Small Changes Beat Rare Big Releases</h3><p>The fear of deployments is understandable. It’s also self-reinforcing. Because deployments are rare and manual, every one feels dangerous. Because every one feels dangerous, teams do them less often. Which means each one bundles more changes. Which makes them more dangerous.</p><p>It’s a trap. Most organizations don’t see it because the trap looks like caution.</p><p>The solution isn’t fewer deployments. It’s more of them — smaller, tested, automated, with clear rollback paths. Here’s what teams running CI/CD in production-critical environments actually report: the more often they deploy, the less each deployment matters. That sounds backwards until you’ve lived both sides of it.</p><p>When deployment is routine, the cognitive load drops. You’re not stress-testing a three-month change bundle. You’re pushing a configuration tweak that’s cleared unit tests, integration tests against OPC UA endpoints, and a canary rollout to one pilot line. If something breaks, you know exactly what changed. You roll back. The line comes back up.</p><p>The incident report is two paragraphs, not two weeks.</p><p><em>Frequent, small, tested changes are safer than infrequent big ones. Every time.</em></p><h3>CI/CD Is a Prerequisite for AAS and DPP — Not an Add-On</h3><p>This is where I push back on a lot of Industry 4.0 consulting. The typical roadmap runs: Asset Administration Shell → OPC UA connectivity → Digital Product Passport compliance → CI/CD pipeline “at some point.”</p><p>That’s backwards.</p><p>The Asset Administration Shell is a living digital twin of your assets. The Digital Product Passport is a regulatory framework that will keep changing — new fields, new formats, new reporting obligations rolling out by product category over the next several years. OPC UA integration touches the real-time data layer driving your entire production reporting stack.</p><p>None of these are set-and-forget. They change. Regularly.</p><p>If your MES connector, your OPC UA gateway, your DPP field-mapping logic can’t be updated through a reproducible, auditable process with a real rollback path — every change to those integrations is a custom firefighting operation. Every time the EU adds a mandatory attribute to your product passport, someone is manually editing a live system and hoping nothing breaks.</p><p><em>You can’t maintain interoperability standards you can’t safely update.</em></p><p>Build the deployment capability first. Then build the integrations on top of it.</p><h3>Audit Readiness Is a Pipeline Feature, Not a Document</h3><p>One argument that genuinely lands with plant managers and quality directors: CI/CD gives you audit trails whether you think about them or not.</p><p>Who changed this logic? When? What tests ran? Which environments got the update and in what order?</p><p>In a manual deployment world, answering those questions means digging through email chains, Confluence pages nobody’s touched since 2021, and hoping the right person kept notes. In a pipeline world, every run records it automatically — version, timestamp, who triggered it, what passed, which environments were hit.</p><p>For ISO 9001, for functional safety standards, for the traceability requirements inside DPP — this is exactly what auditors ask for. It’s also what you want internally when a quality issue surfaces three months after a software change and you need to reconstruct what the system was actually doing at that point.</p><p><em>An audit trail you get automatically is worth more than documentation you have to maintain manually.</em></p><p>The pipeline writes the log. You focus on the code.</p><h3>When to Stop and Fix the Foundation First</h3><p>I sometimes tell clients something they don’t want to hear: if your deployment process is manual, ad hoc, and dependent on two people who coordinate via phone, you’re not ready to build serious Industry 4.0 integrations.</p><p>Not because the integrations are impossible. Because every one you add is another system that needs to change when requirements shift — and right now, you don’t have a safe way to change anything.</p><p>Adding complexity to a system you can’t control is the riskiest move available to you.</p><p>The signs are usually obvious, even if nobody says them out loud. Deployments happen at night with the same two people after a freeze period that stretches for weeks. Rollback means “manually undo what we changed, if we can remember what that was.” Different sites have slightly different configurations and nobody’s sure why. Security patches from two years ago are still under review.</p><p>That’s a process problem. More technology on top of it won’t fix it — it’ll hide it, right up until the next production incident.</p><p>One number tends to focus the conversation quickly: an hour of unplanned downtime in automotive manufacturing runs between €15,000 and €50,000, depending on line complexity. One avoided incident pays for months of pipeline work. That’s before DPP non-compliance enters the picture.</p><h3>Where to Actually Start</h3><p><strong>First:</strong> Make your builds reproducible. Every deployment artifact comes from a CI system, not a developer’s laptop. Identical inputs, identical outputs, every time. If a build can only happen on one specific machine, that’s a truck number of 1 for your delivery process — and you’ve just found your first thing to fix.</p><p><strong>Second:</strong> Add tests that run on every change, not just before major releases. Unit tests for business logic. Integration tests against your OPC UA endpoints. Basic security scanning for your dependencies. Start with 40% coverage on critical paths. That alone changes the risk profile in ways that are hard to overstate.</p><p><strong>Third:</strong> Define your rollback path before you need it. Blue-green deployments, snapshot-based rollbacks, or even a clearly documented manual procedure. Anything beats improvising at 11 PM with a production line standing still.</p><p>You don’t need to automate everything at once. You need to know where you stand and start moving from heroism toward process.</p><p>A system you can’t safely deploy shouldn’t digitalize. Not because the vision is wrong — it’s the right direction. But every integration you build on an uncontrolled foundation becomes a liability instead of an asset.</p><p>Shipping software without panic isn’t a developer skill. It’s a production capability. Treat it like one.</p><p>Build that first. Build everything else on top of it.</p><blockquote><em>Because the conversation worth having isn’t about pipelines and YAML. It’s about who’s responsible when the line goes down.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b5fc73f2432" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The First 10 Things I Would Check in a Fragile Legacy .NET System]]></title>
            <link>https://fries-dotnet-legacy.medium.com/the-first-10-things-i-would-check-in-a-fragile-legacy-net-system-1447411dd90c?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/1447411dd90c</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[legacy-code]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Mon, 11 May 2026 11:11:00 GMT</pubDate>
            <atom:updated>2026-05-11T11:11:00.577Z</atom:updated>
            <content:encoded><![CDATA[<p>You’ve just been handed ownership of a legacy .NET system. Twelve years in production. Nobody knows the full deployment process anymore — or at least, nobody who’s still with the company. The last developer who actually built the thing left eighteen months ago. And now it’s your problem.</p><p>I’ve been in that room. More than once.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FPVCfrv7Nd_QOjIiuDY0hQ.png" /></figure><p>Here’s the pattern I keep seeing: teams inherit a fragile brownfield system and immediately start doing the wrong things. They debate architecture. They talk about code quality scores. Someone proposes a rewrite. Someone else asks which framework should replace the current one.</p><p>I would not start there.</p><p>In a fragile system, the first job is not modernization. It’s diagnosis.</p><p>Before you change anything meaningful, you need to understand where the actual operational risk lives. In most cases, the biggest danger is not “old code.” It’s a mix of invisible dependencies, weak delivery signals, knowledge that lives in one person’s head, and changes that nobody can safely validate before they hit production.</p><p>Here are the first ten things I would check.</p><h3>Check #1: Can the System Actually Be Built Reproducibly?</h3><p>This is one of the fastest reality checks you have — and it costs almost nothing to run.</p><p>If the build only works on one specific machine, or only with one developer’s local environment, or only after undocumented manual steps that someone learned from someone else — the system is already in a dangerous state. Not “needs some attention” dangerous. Operationally dangerous.</p><p>A reproducible build means the codebase still has at least one stable technical entry point. A non-reproducible build means something worse: the team may not fully control the system anymore.</p><p>What I would verify: Does it build cleanly on a fresh environment, or does it need tribal setup knowledge? Are dependencies pinned and restorable? Are private feeds, SDK versions, or environment assumptions documented anywhere — or just remembered?</p><p>If you can’t build the system reliably, every other conversation about stability is built on sand.</p><h3>Check #2: How Does Deployment Actually Happen?</h3><p>Not how people think it happens. Not what the wiki page from 2021 says.</p><p>How it actually happens today.</p><p>In fragile systems, the official deployment process and the real deployment process are often two entirely different things. There may be a documented pipeline. But the actual release still depends on manual file copying, config edits directly on the server, hand-run SQL scripts, or one senior developer who remembers the right sequence — from memory, because that’s the only place it exists.</p><p>That’s not a process. That’s a ritual. And rituals don’t survive vacations or resignations.</p><p>What I would verify: Is deployment automated, semi-automated, or fully manual? Are release steps documented and repeatable by someone who wasn’t there when they were written? Is rollback actually possible, or only theoretically possible? Does releasing require a specific person to be available?</p><p>If deployment is fragile, the code isn’t your only problem. Your delivery system is fragile too. And that’s the part that tends to fail on a Friday afternoon.</p><h3>Check #3: Where Are the Hidden Dependencies?</h3><p>This one gets underestimated almost every time. It’s also where I’ve seen the most expensive surprises.</p><p>A codebase can look perfectly manageable at the file level and still be highly unstable — because dependencies are hidden across services, database tables, configuration files, scheduled jobs, shared libraries, reporting exports, or direct integrations nobody fully maps anymore. These are the things that turn “small changes” into production incidents.</p><p>What I would trace: direct database access shared across multiple applications; shared libraries with unclear ownership (who’s responsible when they break?); integration points that exist but aren’t documented anywhere obvious; cross-system dependencies that get discovered only after a release has already gone wrong.</p><p><strong><em>The most dangerous dependencies are the ones nobody knows exist until they break.</em></strong></p><p>Bad code is painful. Hidden dependencies are expensive. The difference is that bad code usually announces itself.</p><h3>Check #4: What Feedback Does the Team Get Before Production?</h3><p>A fragile system almost always suffers from weak feedback loops.</p><p>The team changes code, but the system gives very little trustworthy information before release. Tests are missing or untrusted. Logs are noisy, or useless, or both. Pipeline checks are shallow. Validation depends too much on human memory and optimism.</p><p>This creates a genuinely dangerous condition: teams stop knowing whether a change is safe. When they stop knowing, they start guessing. When they start guessing at scale, fear fills the gap — and fear is a terrible technical decision-maker.</p><p>What I would check: Do automated tests exist for the critical paths, or only for the easy parts? Do pipeline checks actually catch relevant failures, or mostly syntax errors? Can logs help localize regressions before they reach users? Is pre-production validation meaningful, or mostly a box-ticking exercise?</p><p><strong><em>If the system doesn’t produce good feedback, fear will. And fear makes people stop shipping.</em></strong></p><h3>Check #5: Which Parts Change Often, and Which Parts Break Often?</h3><p>These are not always the same areas. That difference matters more than most people realize.</p><p>Some modules change frequently because the business genuinely depends on them. Other modules break frequently because they’re structurally unstable. The intersection between those two zones — high change frequency, high breakage rate — is where risk concentrates. That’s where stabilization work has the highest leverage.</p><p>What I would look for: hotspots in Git history (which files appear in almost every commit?); recurring incident areas; code areas everyone avoids touching, the places where people “hold their breath” when a release includes them; parts of the system that slow every release down, regardless of what actually changed.</p><p>You don’t need a fancy analysis tool to find most of this. An hour of honest conversation with the team will surface it.</p><h3>Check #6: How Much Knowledge Lives in a Few People?</h3><p>A surprising number of legacy systems are held together by memory rather than structure.</p><p>There’s often one person who knows the deployment sequence. One person who understands the invoicing logic. One person who knows why a specific service must be restarted in a specific order. One person who knows which old workaround must never be removed — and has never written it down because, as far as they’re concerned, “everyone knows.”</p><p>That’s not resilience. That’s deferred risk — and it has a face and a name and a notice period.</p><p>What I would check: Can more than one person work safely in each critical area, or does everything route through the same two names? Does documentation reflect real, current system behavior — or what behavior was intended in 2018? Does important operational knowledge live mainly in Slack threads and habit?</p><p><strong><em>If one resignation, illness, or vacation creates a delivery risk, the problem is bigger than code quality.</em></strong></p><p>The truck number for your most critical systems is worth knowing. If it’s 1, that’s the most important thing you found today.</p><h3>Check #7: How Are Secrets, Config, and Environment Differences Handled?</h3><p>Fragile systems often hide risk in operational details rather than application logic. This category is where I’ve seen the most avoidable production failures — and the most avoidable security incidents.</p><p>Secrets may live in source code, hardcoded into config files that nobody has reviewed in years. Configuration may differ wildly between environments, with nobody quite certain which differences are intentional and which are leftovers from a migration that happened in 2019. Test environments may bear no meaningful resemblance to production.</p><p>What I would check: Are there hardcoded credentials or connection strings in the repository? Is configuration management consistent across environments, or does each environment have its own folklore? When the team deploys to production, do they actually know what’s different — and why?</p><p>These things look secondary until they cause a release to fail, or until they make a security incident possible.</p><h3>Check #8: What Happens When Something Goes Wrong in Production?</h3><p>A system isn’t only defined by how it runs when everything is fine.</p><p>It’s also defined by how quickly and clearly it fails — and how much evidence it leaves behind. In fragile systems, failures tend to be noisy, unclear, and slow to localize. Alerts are vague. Logs are scattered across ten different places. Incident response routes through the same two people every time. Root cause analysis takes most of a day because the system isn’t observable enough to tell you where to look.</p><p>What I would check: How are incidents actually detected — by alerts, by users, or by the on-call developer noticing something strange? Can the team localize a failure quickly, or does it require archaeology? Are runtime signals useful enough to separate symptom from cause?</p><p><strong><em>If failures are hard to understand, every release becomes more emotionally expensive — and eventually teams stop releasing at all.</em></strong></p><p>That slowdown isn’t laziness. It’s rational self-protection. But it’s also a signal that something needs to change.</p><h3>Check #9: Is the Architecture Understandable Enough to Support Safe Decisions?</h3><p>I’m not asking whether it’s elegant. I’m asking whether it’s legible.</p><p>A fragile legacy system doesn’t need architectural purity as a first step. It needs enough clarity that decisions can be made without guesswork — that a developer joining the team next month can orient themselves in a week, not a quarter.</p><p>What I would check: Are subsystem boundaries visible, or does everything connect to everything else in ways that aren’t obvious? Is data flow understandable? Is there any current, trusted map of the system landscape — even an informal whiteboard photo from six months ago?</p><p>Without this, teams don’t really make architectural decisions. They place bets. In production-critical systems, that’s a bad game.</p><h3>Check #10: What Is the Cheapest Move That Would Reduce Risk Right Now?</h3><p>This is where many assessments go wrong.</p><p>They identify the problems correctly — then jump too fast toward large programs, platform redesigns, or transformation roadmaps. Most fragile systems don’t need a heroic plan as a first step. They need one or two intelligent stabilizing moves that improve trust and give the team a reason to believe that change is actually possible.</p><p>What I would look for: one brittle manual deployment step that can be standardized; one critical regression path that deserves real automated coverage; one hidden dependency that can be made visible before the next release; one hotspot that needs monitoring before anyone touches it further; one operational weakness that causes repeated, avoidable stress.</p><p>The right first move is usually not glamorous. It is useful.</p><p><strong><em>A team that can deploy safely and confidently is already in a better position than most.</em></strong></p><h3>What This Is Really About</h3><p>When I look at a fragile legacy .NET system, I’m not trying to answer “how do we modernize everything?”</p><p>I’m trying to answer four smaller questions: Where is the real risk — not the theoretical risk, the operational risk that exists this week, in the next release? What is making change unsafe? What does the team not see clearly enough yet? And which first steps would reduce uncertainty fastest — not the most ambitious steps, the most useful ones?</p><p>Legacy systems rarely become dangerous because they’re old. They become dangerous when nobody can change them with confidence anymore. The code age isn’t the problem. The loss of control is.</p><p>That’s why diagnosis comes first. If you can’t see the system clearly, you shouldn’t trust your transformation plan yet.</p><p>After seventeen years working in production-critical .NET environments, the thing that took me longest to accept is this: the teams that stabilize legacy systems fastest are not the ones who move fastest. They’re the ones who understand the system before they change it.</p><p>Diagnosis is not a delay. It’s what makes every subsequent move cheaper.</p><p>If you’re standing in front of a fragile brownfield system right now, start with these ten checks before touching anything else. Not because you need perfect information — you won’t get it. But because ten hours of honest diagnosis will protect you from ten weeks of expensive mistakes.</p><p>Because the system is always more complex than the diagram suggests — and the risk is always closer than it looks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1447411dd90c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Legacy Code Isn’t Garbage. It’s Your System’s Memory.]]></title>
            <link>https://fries-dotnet-legacy.medium.com/legacy-code-isnt-garbage-it-s-your-system-s-memory-f991a41746bf?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/f991a41746bf</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Mon, 04 May 2026 06:26:01 GMT</pubDate>
            <atom:updated>2026-05-04T06:26:01.355Z</atom:updated>
            <content:encoded><![CDATA[<h4>The pull request looked clean. Simpler logic. Fewer conditions. Exactly what “good code” is supposed to look like.</h4><p>Three days later, a production outage. A specific customer’s order-processing workflow — silently broken since the “improvement.”</p><p>The developer who wrote the refactor wasn’t careless. By every reasonable measure, he was doing his job well. He’d just done it without understanding <em>why</em> the old code was written that way.</p><p>That’s the trap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SuzKDBAYrvaHgcv7TLSDyg.png" /></figure><h3>The Instinct Is Right. The Order Is Wrong.</h3><p>When developers encounter legacy code, the instinct to improve it is correct.</p><p>The problem isn’t the impulse. It’s the sequence.</p><p>Most teams start by identifying messy code, then refactor for clarity, then remove what looks like unnecessary complexity. The most important step isn’t in that list: understanding <em>why</em> the code became this way.</p><p>Skip that, and you’re not improving the system. You’re rewriting it blind.</p><p><em>The code doesn’t just execute logic. It stores decisions.</em></p><h3>Every Strange Condition Was Once a Solution</h3><p>Here’s what took me years to really internalize about legacy systems.</p><p>Every ugly workaround, every cryptic condition, every “who on earth wrote this?” block of code was, at some point, a solution to a real problem. A production incident at 2 a.m. A customer escalation that forced a workaround. An external system that didn’t behave as documented.</p><p>The system evolved in response to reality. That evolution lives in the code because it was never written down anywhere else.</p><p>G.K. Chesterton described this better than anyone: if you come across a fence in the middle of a field and don’t understand why it’s there, you don’t remove it. You <em>find out why it’s there first</em>. The same logic applies to that nested if-statement you’re about to delete.</p><p><em>If the code exists and the system still runs, assume it’s there for a reason.</em></p><h3>Why Documentation Won’t Save You</h3><p>At this point, someone usually says: “We just need better documentation.”</p><p>That helps. It’s not a solution.</p><p>Most of the critical knowledge in legacy systems was never explicit. It was learned through incidents — failures that forced a response. That response became code. Nobody documented it because there was no time, and because it felt obvious to the person who was there.</p><p>Michael Feathers, in <em>Working Effectively with Legacy Code</em>, introduces “characterization tests” — tests that don’t ask whether the behavior is <em>correct</em>, but simply capture what the system <em>actually does</em>. That distinction matters enormously. You’re not validating the design. You’re extracting the knowledge.</p><p><em>A characterization test shows what the system does. Not what someone wrote down two years ago. The actual, executable, verifiable behavior.</em></p><p>That’s knowledge you can carry forward safely.</p><h3>Clean Code Can Be Dangerously Wrong</h3><p>There’s a specific failure pattern I’ve seen repeatedly in brownfield projects.</p><p>After a refactor, everything looks better. The code is cleaner. The structure makes more sense. Developers feel productive. And for a while, everything seems fine.</p><p>Then something breaks. Not immediately — weeks or months later, in a specific edge case nobody thought to test because it looked like it couldn’t happen. Except it could. The old code knew that. The new code doesn’t.</p><p>Cleaner code often means fewer conditions, simpler flows, less defensive logic. Which also means fewer safeguards, missing edge cases, lost behavior.</p><p><em>The system becomes easier to read. But less correct.</em></p><p>Understanding comes before improving. Not the other way around.</p><h3>The “Let’s Rebuild It Properly” Trap</h3><p>Every few years, a team reaches a breaking point and makes the call: we’re rewriting it from scratch.</p><p>Joel Spolsky called this “<strong>the single worst strategic mistake that any software company can make</strong>.” The examples are everywhere. Netscape rewrote their browser from scratch in 1999. It took three years. What shipped was, in many ways, worse than what they’d had — because the old system carried fifteen years of browser quirks, real-world edge cases, and accumulated behavior that the rewrite team simply had no access to.</p><p>The pattern repeats constantly in smaller codebases that nobody writes articles about.</p><p>If you don’t understand what the existing system does, you won’t build a better one. You’ll rebuild the same problems.</p><p>Just cleaner.</p><h3>Before You Touch It, Read It Like an Archaeologist</h3><p>Legacy systems don’t document themselves. You have to dig.</p><p>Start with production logs and past incidents, not the code itself. Find out what actually happens, not what the code is supposed to do. The gap between those two things is where all the important information lives.</p><p>Then talk to whoever worked on the system — even a ten-minute conversation about one specific module can save weeks of reverse engineering. People carry knowledge that never made it into any commit message.</p><p>Write characterization tests before you change anything. Not to validate the design — to make it impossible for critical behavior to break silently without you knowing.</p><p><em>Only after that do you start improving things.</em></p><h3>It’s Not Technical Debt. It’s Institutional Memory.</h3><p>Legacy systems are validated business logic. Behavior that’s been tested against reality, often in ways that were painful and expensive.</p><p>Clearing that away isn’t modernization. It’s amnesia.</p><p>Modernizing means understanding what’s already there, extracting the critical knowledge, stabilizing it, then improving incrementally. Not everything needs to be kept. But everything needs to be understood first.</p><blockquote><em>Legacy code is not pretty. But it has survived reality. New code hasn’t.</em></blockquote><h3>What You Can Do Before Your Next Refactor</h3><p>Three things, and none of them need a process change or a team conversation to start.</p><p><strong>First:</strong> Before touching a single line, ask <em>why</em> the code is written the way it is. Not what it does — why it does it that way. The answer is usually in git history, an old ticket, or a fifteen-minute call with the right person.</p><p><strong>Second:</strong> Write characterization tests for the critical paths before you change them. Treat them as discovery work. You’re mapping unknown territory, not doing housekeeping.</p><p><strong>Third:</strong> Find whoever last touched that module. Ask one specific question. Ten minutes of that conversation is worth a full day of reading code alone.</p><p>If you want a quick assessment on your system, check my free self-assessment on my website: <a href="https://oliverfries.com/">https://oliverfries.com</a></p><p>If this changed how you think about legacy code:</p><ul><li><strong>Clap</strong> if it’s worth passing on</li><li><strong>Comment</strong> with a specific example from your own codebase — the messier the better</li><li><strong>Share</strong> with someone who’s about to kick off a “cleanup” sprint</li></ul><p>Because the most dangerous code isn’t the code that looks broken.</p><p>It’s the code that looks fine — after someone removed the fence.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f991a41746bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your System Isn’t Stable If You’re Afraid to Deploy.]]></title>
            <link>https://fries-dotnet-legacy.medium.com/your-system-isnt-stable-if-you-re-afraid-to-deploy-5f75eb7cadd5?source=rss-3cddc1ffa27d------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f75eb7cadd5</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[leadership]]></category>
            <dc:creator><![CDATA[Oliver Fries]]></dc:creator>
            <pubDate>Thu, 30 Apr 2026 06:16:01 GMT</pubDate>
            <atom:updated>2026-04-30T06:16:01.284Z</atom:updated>
            <content:encoded><![CDATA[<h4>The difference between frozen and reliable — and why it matters in production-critical environments</h4><p>That sounds harsh.</p><p>It’s also usually true.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qlk-BHQRt3U8Qq592rmqog.png" /></figure><h3>The Illusion of Stability</h3><p>I’ve seen this profile in production-critical systems more times than I can count:</p><ul><li>Two releases per year</li><li>Four-hour build times</li><li>No documented deployment process</li><li>One person who “understands everything”</li></ul><p>And the conclusion is always the same: <em>“The system is stable.”</em></p><p>No. It’s not stable. It’s frozen.</p><p>These are not the same thing. Treating them as equivalent quietly drives teams toward a kind of paralysis that’s hard to diagnose, because everyone involved genuinely believes they’re being careful.</p><h3>What “Stable” Actually Means</h3><p>Real stability is not the absence of deployments. It’s the ability to deploy without fear.</p><p>Can you deploy without holding your breath? Do you know what might break? Do you have a rollback plan that’s been rehearsed, not just written down? Does the system behave predictably when something changes?</p><p>If any of those answers involve uncertainty or a specific person’s phone number, you don’t have stability. You have avoidance dressed up as caution.</p><h3>The Moment Everything Slows Down</h3><p>It usually starts small. A release goes wrong.</p><p>Nothing catastrophic. Painful enough: late-night debugging, a hotfix pushed directly to the server, an uncomfortable retrospective. The team reacts — not in a meeting, not with a formal decision, but structurally. They start deploying less often.</p><p>“Let’s be more careful next time.”</p><p>That sounds responsible. It also tends to be the beginning of a feedback loop nobody intended to start.</p><h3>The Fear Loop</h3><p>One risky release causes problems. The team reduces deployment frequency. Changes accumulate. The next release is larger and riskier. Confidence drops. Releases happen even less often.</p><p>Every step feels like prudent risk management. The cumulative result is the opposite.</p><p><strong><em>The longer you wait between deployments, the riskier each one becomes — not safer.</em></strong></p><p>The batch size grows. Unknown interactions between changes multiply. Testing loses meaning as the gap between test environment and current production keeps widening. Rollbacks get harder because too much has changed at once.</p><p>At some point you’re no longer shipping software. You’re organizing events. Big, stressful, high-stakes events that everyone quietly dreads for weeks beforehand.</p><h3>The Cost Nobody Calculates</h3><p>On the surface, fewer releases feel safer. The team isn’t touching the system as often. Nothing is visibly breaking.</p><p>But the risk isn’t decreasing. It’s just invisible.</p><p>I once worked on a legacy MES integration where the team was proud of their “zero production incidents last quarter.” When I asked how many deployments they’d made in that period, the answer was one. And they’d been building toward the next one for three months.</p><p>They didn’t have zero incidents because the system was reliable. They had zero incidents because they’d essentially stopped changing it. The moment we had to ship a compliance-required update, three months of bundled changes hit production and took two days to stabilize.</p><p>Zero incidents. Two-day recovery. Not the same thing as stable.</p><h3>What the Data Says</h3><p>Counterintuitive, but ten years of DORA research — over 39,000 professionals surveyed — keeps showing the same result: teams that deploy more frequently are more stable.</p><p>Elite performers average 182 times more deployments per year than low performers, with an 8 times lower change failure rate.</p><p>More deployments. Lower failure rate. The research has been making this argument for a decade, and the industry keeps being surprised by it.</p><p>Teams with manual deployment pipelines deploy less often, which increases batch size, which makes each deployment a bigger effort, which means feedback arrives too late to act on quickly.</p><p><strong><em>Infrequent deployment is not a symptom of a stable system. It’s a symptom of a system nobody trusts.</em></strong></p><h3>“We Only Deploy Twice a Year”</h3><p>I hear this framed as caution. It reads as a warning sign.</p><p>The relevant question isn’t “How often do you deploy?” It’s “Why don’t you deploy more often?” The honest answer, almost every time, is some version of: we don’t fully trust what will happen.</p><p>That distrust is not a reason to deploy less. It’s a reason to invest in making deployment safer: smaller changes, better coverage on critical paths, a pipeline that more than one person can actually run.</p><h3>Stability Is Not a Mindset Problem</h3><p>Teams often land on a confidence diagnosis. If we were just more willing to take risks…</p><p>That’s the wrong frame. Confidence without structure is gambling, and you don’t fix this by deciding to be brave. You fix it by making deploying predictable.</p><p>In production-critical environments, that means a few concrete things:</p><ul><li><strong>Small, focused changes</strong> — each deployment has a limited, clear scope</li><li><strong>Short feedback cycles</strong> — you know within minutes, not days, whether something broke</li><li><strong>Reproducible builds</strong> — same inputs, same outputs, every time</li><li><strong>Shared deployment knowledge</strong> — at least three people can run the process without calling anyone</li><li><strong>Tests that protect critical paths</strong> — not everything, just the things that actually matter</li></ul><p>None of this is glamorous. All of it is necessary.</p><h3>The Shift That Changes Everything</h3><p>The goal isn’t to deploy more often as a metric.</p><p>The goal is to make deploying boring.</p><p>When deployments become routine — small, frequent, well-understood — the risk profile flips. Each change is tiny. When something goes wrong, the delta is small and the fix is obvious. Recovery time drops. Confidence climbs. The system becomes understandable again.</p><p><strong><em>Real stability is not the absence of change. It’s the ability to handle change without fear.</em></strong></p><p>There’s a real difference between a team that dreads release day and a team that barely notices it.</p><h3>A Quick Diagnostic</h3><p>Three honest questions:</p><p>How often does your team deploy to production? How does the team feel in the hour before hitting deploy? What’s the actual rollback plan, and has it been tested in practice?</p><p>If any of those answers involve stress, uncertainty, or “we’d call [name]” — you don’t have a stable system. You have a system you’re trying not to touch. And the longer you avoid it, the more fragile it gets.</p><h3>What You Can Do This Week</h3><p>You don’t fix deployment avoidance by scheduling more deployments. You fix it by removing the specific reasons deployment feels risky.</p><p><strong>First:</strong> Name the friction. Is it the build process? Lack of coverage on a critical path? A manual step only one person knows? You can’t fix something you haven’t diagnosed.</p><p><strong>Second:</strong> Make one deployment smaller. Take whatever’s queued for the next release and cut it in half. Ship the smaller version. The goal is to break the “big release event” habit with one concrete step.</p><p><strong>Third:</strong> Document the deployment process — not for compliance, but for survivability. If your deployment owner were unavailable tomorrow, who runs it? If the answer is unclear, that’s your truck number problem made visible.</p><p>Stability is built in small steps. It doesn’t require a transformation program. It requires honest diagnosis and the willingness to start somewhere.</p><h3>Final Thought</h3><p>After 17 years in production-critical .NET systems, deployment fear is one of the most consistently misdiagnosed problems I’ve run into. It looks like caution. It’s measured in incident-free quarters. It gets rewarded.</p><p>It’s also a trap.</p><p>The system that never breaks because you never touch it isn’t stable. It’s waiting. When it finally breaks — because something will change that you can’t avoid — it breaks badly, because the team’s ability to handle change has quietly atrophied.</p><p>Real stability is the ability to change, frequently and confidently, because the process is understood and the risk is small.</p><p>If your team is afraid to deploy, that’s not a sign to deploy less. It’s a sign to start building the thing that makes deploying safe.</p><ul><li><strong>Clap</strong> if this reframed how you think about deployment risk</li><li><strong>Comment</strong> with the one thing that makes your team hesitate before hitting deploy</li><li><strong>Share</strong> with a tech lead who uses “stability” to mean “we don’t touch it”</li></ul><p>Because the most dangerous system isn’t the one that fails. It’s the one that hasn’t failed yet — and nobody knows why.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f75eb7cadd5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>