Phasing a live product redesign: what goes in phase one, and what can wait

Phase one of a live product redesign should make every later phase cheaper: the structure, shared components and the task people do most. How to sequence it.

  • Product Modernisation
  • Product Design
  • B2B SaaS and workflow software
  • B2B SaaS & Workflow Software
Insights

Phase one of a live product redesign should make every later phase cheaper: the structure, shared components and the task people do most. How to sequence it. Phase one of a live product redesign should be the work that makes every later phase cheaper: the information architecture and navigation, a small seed of shared

Phase one of a live product redesign should be the work that makes every later phase cheaper: the information architecture and navigation, a small seed of shared components, and the task your users do most, redesigned end to end. The most visible screens, such as the dashboard or the login page, can wait. Sequence the rest by four tests (frequency, dependency, risk and visibility), keep design no more than one slice ahead of what engineering can build, and record everything you defer, with the seam that will let you change it later.

This page is about sequencing. If your question is whether to redesign at all, or to rebuild, start with our guide to the rebuild or modernise decision. If you are building something new rather than changing a product people already use, the logic is different: see what a SaaS MVP must prove.

Why phase one should make later phases cheaper

A redesign of a product in use is a series of releases, not one. Customers keep working while it happens, engineering still has a roadmap, and nobody can stop the business for a year. So the real design decision is the order.

Software engineering has a well-documented answer to a version of this question. Martin Fowler's Strangler Fig describes replacing a legacy system piece by piece, moving behaviour into the new code base gradually instead of switching everything at once. He writes that he has seen the plan of replacing everything at once "go down in flames most of the time", and that each delivered piece teaches the team something that improves the next decision. On the design side, Hoa Loranger at Nielsen Norman Group makes the same case in her article Radical Redesign or Incremental Change?: default to incremental change, and only go for a complete redesign when the data says so, because radical change is more likely to break something users rely on.

Phasing is agreed, then. The mistake to avoid is choosing phase one by how impressive it will look. A team redesigns the dashboard and the marketing-facing screens first, because they demo well. Then the navigation model changes in phase two, the components are rebuilt in phase three, and the showcase screens are redone twice. The order that holds up is the reverse: settle what everything else is built on, prove it on real work, then spread it.


Score every candidate on four tests

List the areas of the product as tasks people do, not as screens. "Approve an invoice" is a candidate; "the invoices page" is not, because one task can cross several screens and one screen can serve several tasks. Then score each task on four tests.

  • Frequency. How often is it done, and by how many people? Take this from product analytics, not opinion. Gerry McGovern's top tasks research defines them as the small set of tasks, "usually less than 10, often less than five", that matter most to customers; in one of his votes, three tasks drew as much of the vote as the bottom 44. Check your own analytics for the same shape: a short list of tasks carrying most of the use.
  • Dependency. How many later screens will reuse what this item settles? Navigation, the page layout, forms, tables, filters and the colour and type tokens sit under almost everything. Settling them first means later phases assemble rather than invent.
  • Risk. What would a wrong change cost users? Billing, permissions, irreversible actions and anything an integration or export depends on score high. A high score does not push an item first or last on its own. It means the item moves only after the patterns it will use are proved, in a smaller slice, with a way back. The exception is when the current design is itself causing the harm: then it may need to go early.
  • Visibility. How much will people notice? This is a real consideration for communication and for the sales team, but it is the weakest reason to go first. Visibility on its own never earns a place in phase one.

The inputs are the ones any redesign should start from: analytics for frequency, support history and interviews for pain and risk, and an inventory of the interface for dependency. Brad Frost's interface inventory is a practical way to do the last one: collect every button, form, table and pattern side by side, and the duplication shows you which components the product actually needs.

Here is a worked example for a generic B2B SaaS product. Scores are high (H), medium (M) or low (L), and the last column applies the rule below the table.

CandidateFrequencyDependencyRiskVisibilityPhase
Navigation and information architectureHHMHOne
Component seed: tokens, forms, tables, filtersMHLMOne
Most-used task, end to end (for example, create and assign a record)HMMMOne
Next most-used tasks that reuse the same componentsMMMMTwo
Search and saved viewsMMMLTwo
Dashboard or home screen visual refreshMLLHTwo or three
Billing, plans and permissionsLLHLThree, after patterns are proved
Reports and exportsLLHLThree
Admin settingsLLMLThree

The rule: an item goes in phase one if its dependency is high, or if its frequency is high and its risk is manageable. High risk with low frequency waits for proven patterns. High visibility with low dependency waits, however tempting it is to show off.


What belongs in phase one

Three things belong there.

The structure. The information architecture and the navigation model decide where every later screen lives. If they change after other screens are redesigned, those screens move, their labels change and their entry points break. Phase one should produce the navigation model and the map of where tasks live, even if the old screens still sit behind it for a while.

A seed of the design system, not the whole system. Phase one needs the tokens (colour, type, spacing) and the components the first task uses: for example form fields, buttons, a table, filters, feedback messages and an empty state. A full component library built before any task uses it is design running ahead of the product. Grow the system as each phase needs it.

The task people do most, redesigned end to end. This is where the structure and the components meet real work. It gives users something better early, and it tests the foundations against the hardest conditions before they spread: real data, real edge cases, real habits.

This is the order we followed with Benchmark Gensuite, whose suite has more than 75 applications. As the case study sets out, the work started at the shared component layer, where one choice affects every application, then moved into one high-use feature, the scope selector that every application depends on. We built the direction as coded prototypes so Benchmark's engineers could check whether it could be built before wider implementation.


What can wait, and how to tell

Deferral is not a judgement that something is unimportant. It is a judgement that changing it now would cost more than changing it later, once the foundations exist. Good candidates to wait:

  • low-frequency areas such as admin settings, account configuration and reports few people open;
  • high-risk, low-frequency flows such as billing, plan changes and permission editing, until the patterns are proved elsewhere;
  • visual polish on screens whose structure is not changing;
  • showcase screens, such as the dashboard, whose content depends on components still being settled;
  • edge-case features used by a handful of accounts, which deserve a conversation with those accounts before they change.

Before you move an item into a later phase, check it against this list. It is safe to defer if every answer is yes.

  1. No phase-one item depends on it. Nothing you are about to build has to change it to work.
  2. It can sit next to the new design without breaking a task. A user crossing from a new screen to an old one can still finish what they started.
  3. It can take on new tokens without a redesign. Old screens can adopt colour and type changes, so the gap between old and new does not look like two products.
  4. Its current problems are known and recorded. Someone has written down what is wrong with it and what that costs in the meantime.
  5. There is a trigger to revisit it. A date, a phase or an event, not "later".
  6. It has an owner. One named person tracks it.
  7. No regulatory or contractual change will force it sooner. If one will, plan for that date instead.

An example three-phase plan

This is a generic shape, not a client's plan. Durations depend on the product and the team, so none are given here.

Phase one: foundations and the most-used task.

  • Map the information architecture and decide the navigation model.
  • Define the tokens and build the components the first task needs.
  • Redesign the most-used task end to end, with existing users testing it.
  • Build the seams: a navigation shell that can host old and new screens, and release flags for the new task.
  • Open the deferral register (see below) and enter everything you chose not to do.
  • Release to a small group first, with a way back.

Phase two: spread the patterns.

  • Move the next most-used tasks onto the new components, starting with those that share the most components with phase one.
  • Redesign search, filters and saved views, which reuse the table and filter components.
  • Retire old components as their last screen moves, not before.
  • Review the deferral register and promote anything whose trigger has fired.

Phase three: the long tail and the clean-up.

  • Move low-frequency and high-risk areas onto proven patterns: admin, billing, permissions, reports and exports.
  • Refresh the showcase screens now that their components are stable.
  • Remove transitional code, release flags and duplicate components.
  • Close or consciously keep each remaining item on the register.

Each phase ends with something users can use. If a phase only produces designs or a component library, it is a stage of work, not a phase of the redesign.


Keep design within reach of engineering

The most common way a phased redesign drifts is that design finishes far more than engineering can build. Designers can produce screens faster than a team can ship them, and an established product has a feature roadmap competing for the same developers. The result is a growing pile of approved designs that age before they are built: the product changes underneath them, the components move on, and the designs are reworked or quietly abandoned.

Treat that pile as inventory with a cost, and keep it small.

  • Design one slice ahead, not one product ahead. Design should be about one delivery slice ahead of the build, close enough that engineers can still change it. The software delivery research programme DORA recommends working in small batches because small batches shorten the feedback loop, and treats any batch that takes longer than a week to complete and check as too big. The same reasoning applies to the design slices you hand over.
  • Count designed but unbuilt screens. Agree a limit with engineering. When the pile reaches it, designers move to research, testing and the deferral register instead of more screens.
  • Design to the components that exist in this phase. A screen that needs five new components is a phase-two screen, whatever its priority.
  • Put engineers in design review, with something that runs. A coded prototype lets engineers test feasibility while the decision is still open, not after sign-off.
  • Accept work on built behaviour, not on mock-ups. A phase is done when the redesigned task works in the product, not when its screens are approved.

Defer safely: record the debt and leave the seams

Every deferral is a loan. Ward Cunningham's original debt metaphor described shipping first-time code as going into debt, with every minute spent on not-quite-right code as interest. Deferred design works the same way: the old screen keeps costing support time, training effort and inconsistency until it moves. Debt you have recorded can be managed. Debt you have forgotten turns up as a surprise in phase three.

Keep a deferral register. One line per deferred item, reviewed at the start of each phase:

FieldWhat it records
ItemThe task or area, named as users would name it
Why it waitsWhich of the four tests put it later
InterestWhat leaving it costs meanwhile: support load, errors, workarounds, inconsistency
SeamHow it will change later without reopening phase-one work
TriggerThe date, phase or event that brings it forward
OwnerThe one person who tracks it

Leave seams on purpose. Fowler describes seams as the places where a system can be split, and transitional architecture as the temporary code that lets old and new run side by side until the old part goes. In an interface, the useful seams are:

  • a navigation shell that can link to old and new screens, so tasks move one at a time;
  • design tokens that old screens can adopt, so the visual gap closes before the structure changes;
  • route or module boundaries, so one area can be replaced without touching its neighbours;
  • release flags around new tasks, so a change can be shown to a group and switched back.

Flags are themselves a deferral. Pete Hodgson's Feature Toggles describes release toggles as a way to ship unfinished code paths to production as latent code, and warns that toggles carry a cost and that teams must be proactive in removing the ones no longer needed. Put every flag in the register with a removal trigger, the same as any other debt.


Keep your users through the change

Sequencing decides what changes when. Keeping users decides how each change lands: who sees it first, what they are told and how they get back if it goes wrong. We cover that in how to redesign a live SaaS product without losing users, including staged releases and testing with the people who stand to lose something. The two plans should be one plan: each phase in this page needs a release step from that one.


Signs your phase plan is failing

Watch for these at each phase review.

  • Phase one keeps growing. Items join "because we are in there anyway", and the first release date moves.
  • The designed but unbuilt pile is growing. Design has run ahead, and some of that work will be redone.
  • Phase-two work is reopening phase-one screens. The foundations were not settled before work spread.
  • Old and new patterns have run side by side with no retirement date. Transitional code has become permanent.
  • Flags are never removed. The register lists them but nobody closes them.
  • The deferral register has not been reviewed since it was written. Deferral has turned into forgetting.
  • Support questions shift from "how do I" to "where did it go". Users are losing their way between old and new, a sign that the navigation seam is not doing its job.
  • The plan is still organised by screens. If the phases read as lists of pages, go back and rescore them as tasks.

If you want an outside view of the order before you commit, our product modernisation assessment sets out what to keep, change or rebuild and in what order, and our product redesign service carries the phases through, starting with the workflow that causes most friction.

About the authors

  • Rakesh Chitroda

    Co-founder

    Rakesh Chitroda is a co-founder of Tcules and writes for teams choosing an outside partner for product work. Rakesh's guides cover how to choose a product design agency, what a product design agency does, when to hire a design system consultant, how to choose a UX audit agency or a front-end development agency, and how to compare software modernisation companies. Other pieces deal with cost and working arrangements: what an MVP costs to design and build, hiring a product designer for a SaaS product, and outsourcing UX design without losing product knowledge.

    LinkedInMore from Rakesh
  • Yash Gidwani

    Product Designer

    Yash Gidwani is a Product Designer at Tcules who writes about getting people into a SaaS product and keeping them there. Yash's guides cover SaaS onboarding strategies, onboarding and engagement software, and redesigning a live product without upsetting the people who use it. Other articles go into specific workflows: lending and loan origination apps, insurance quoting and claims, staffing and recruitment software, and a search-first create flow that stops duplicate records. Yash has also co-written the SaaS UX audit checklist and a 20-question checklist for legacy modernisation readiness.

    More from Yash

Planning the phases of a redesign?

Phase one is the hardest call in a redesign, so talk it through with us.