Application & Data Migration Blog Posts | GAPVelocity AI

Why Your Modernized App Still Feels Like Legacy

Written by Oscar Poveda | Nov 19, 2026, 1:02:04 AM

Adding a UI/UX Redesign Pass to Legacy Modernizations

When we run a modernization POC, the first two weeks produce a working front-end. The forward-deployed engineer takes the legacy forms and brings them up on a modern stack: React with Material UI, or Blazor with MudBlazor. The client sees it and likes it. Then a user opens the new screen to save a record and it still takes seven clicks, the same seven clicks it took in the desktop executable. The controls are rendered by a modern component library, but the application behaves exactly as it did before. What closes that gap is a UI/UX redesign pass on top of the port, done in the right order.

What a screen port actually preserves

A migration tool maps each legacy control to a component in the target library: a text box becomes a text field, a grid becomes a data grid, a button becomes a button. Layout is preserved because the original coordinates are the only layout specification the tool has. Some controls come out slightly larger, and the page may become responsive, but that is the extent of the change. The result is a basic design that is correct by construction, because the component library supplies the modern look and the tool supplies nothing beyond a one-to-one mapping.

That one-to-one mapping is what makes the port verifiable. Every screen in the target corresponds to one screen in the source, every action corresponds to one action, and behavior can be compared side by side. During the modernization that is a feature. After the modernization it is the problem: the interaction graph of the application, meaning the number of screens, the modal chains, the order of steps in each flow and the number of clicks per task, is a copy of the original. The port changes the rendering layer and leaves the interaction model untouched.

Why the backend work is invisible to users

Most of the engineering effort in a modernization lands in the backend, and it is real work. The modernized code follows current design patterns, keeps a separation of concerns, has structured logging and centralized exception handling, and is no longer spaghetti. All of that improves maintainability and lowers the cost of every future change.

None of it is visible to the end user. From their side, the executable they used to run now opens in a browser. The number of clicks is the same, the output is the same, and the effort to complete a task is the same. In some cases it is higher, because they have to adapt to a new interaction model that offers no benefit in return. Users in this position tend to feel cheated, and they say so: it is the same application, it just looks newer. A technology swap from an old stack to a new one, with the user experience carried over intact, is not something a user will recognize as modernization.

Where the redesign has to come from

Redesigning the interaction model is a different discipline from porting it. Given a working port, a developer sees controls, data bindings and flows, and isn’t looking for signs that a flow could be cut in half or that three windows could collapse into one panel with context. Asking the engineering team to do that on top of the port usually produces cosmetic changes.

What worked was adding a UI/UX designer to the POC. The designer got the same briefing the engineers did, directly from the client: the application is hard to operate, and this is where it hurts. Within two to three days the designs were ready. The designer looked at the application as something people operate every day and that perspective is what the port lacked.

Client case: a color-coded interface from another era

One healthcare industry client came to us with an ASP.NET application and a problem that was not technical at first glance: their own customers were leaving because the application was cumbersome to operate. When the application was originally built, every label on screen had been given its own color from a palette, so opening a form meant looking at a rainbow. It was the convention of its time. Over the years the team had grown afraid to change it, because nobody was sure how.

Other symptoms were typical of an application that had grown by accretion:

  • screens called dashboards that were blocks of text, with no charts
  • grids where every row opened its own contextual modal
  • long flows with steps that existed for historical reasons and not for the business
  • navigation that required opening a new window to see related context

Directly porting the interface would have carried those flaws straight into the new stack, merely rendered with updated controls. Intervening with a redesign fixed them at the root. We condensed the steps to mirror real operational needs. Supporting details that previously demanded separate windows shifted into side panels and contextual overlays. Text-heavy summaries turned into actionable analytical dashboards that anchor the user experience. Instead of launching pop-ups for every row, grids expanded inline, and the multi-colored label scheme was discarded entirely.

The operational impact was immediately quantifiable. Executing a core routine task dropped from roughly a hundred manual actions down to two—a 98% click reduction—remaining constant regardless of volume, whereas the legacy layout scaled up to a thousand interactions for larger batches. Secondary operations saw step counts fall by 50% to 75%, dead-end screens were eliminated, and in-place details removed the constant context switching. Cognitive load dropped alongside click counts: users no longer held values in memory across views or scanned massive menus, noise was filtered out by hiding three-quarters of non-essential visual elements, and key status indicators ceased relying purely on visual hue.

The strategic shift was clear to leadership from their first interaction with the prototype. Their VP of Engineering and VP of AI Strategy noted that operating the system had become intuitive and streamlined, characterizing the leap forward in user experience as light-years ahead of the initial system.

Sequencing: port first, then redesign on top

The redesign comes after the port, and the order matters.

The port moves the business rules into a modern codebase where they are separated from the view. That separation is what the backend work buys you. Once the rules live in services rather than in form event handlers, the interaction layer can be reshaped without touching them. Flows can be shortened, screens merged and context relocated, and the rules underneath stay verifiable against the original.

Doing the redesign first, on the legacy code, is not an option, because the rules are entangled with the screens. Doing only the port leaves the user with the result described earlier. Doing the port and then the redesign gives you a modern backend and a modern interaction model, each built on the other.

In our experience the design produced in the first two weeks of a POC is good, and clients like it, because it is a modern-looking version of what they know. Adding the UI/UX pass changes the nature of the reaction. The client stops evaluating a technology demonstration and starts recognizing the application they will use every day.

Design principles

Separate the rendering layer from the interaction model, and know which one the port changed. A component library modernizes the first. Only a redesign changes the second. Measure the second in clicks per task, screens per flow and windows open at once, because that is what the user measures.

Verify the port against the original; redesign against the business. Side-by-side comparison with the legacy screens is the right check for the port. It is the wrong check for the redesign, whose purpose is to stop matching the original.

Bring a designer into the POC, not after it. The two to three days of design work has a disproportionate effect on how the client evaluates the result, and it depends on the same client briefing the engineers already receive.

Treat the backend modernization as necessary and the UI/UX pass as what makes it visible. New patterns, new architecture and clean separation of concerns are the foundation. The interaction redesign is what lets the user see that anything changed. An application is fully modernized only when both its architecture and its interaction model have been rebuilt.

What this means for you

Automated migration tooling has made the mechanical part of a modernization reliable: forms, modules and data access come across, business rules land in a codebase that is maintainable, and the result can be verified screen by screen against the original. That is necessary work and none of it should be skipped. But the port is judged by engineers, and the application is judged by the people who use it, and those two groups are looking at different things. A port reproduces the interaction model it was given, so the user inherits every long flow and every window chain of the system they were promised to be rid of. The UI/UX redesign pass is what closes that gap, and it is cheap relative to the rest of the project: a designer with the client’s briefing, a few days of work and a prototype the client can operate rather than look at. Done in that order, the backend has been rebuilt and the user can tell.