By Nick Babich
Enterprise UX design is the design of software employees must use for work, where buyers rarely use it and old systems can't just be switched off.
That is why most of the work on an ERP, CRM, HR or procurement tool happens around the screens: agreeing who signs off, finding what the old system really does, and moving thousands of people to the new version without stopping the business. This guide walks through those three parts in the order a typical project meets them. If you are already comparing outside partners for this kind of work, see the enterprise UX design agencies we compare for large organizations.
Key Takeaways
- Buyers are not users: the people who fund and approve enterprise software rarely use it every day, so the project needs a plan for both groups from the first week.
- Map sign-offs before you design: IT, security, legal, procurement and, in some countries, the works council can each stop a release, so name who decides what and by when.
- Audit the legacy system first: undocumented business rules, workarounds and shadow spreadsheets are part of the real workflow, and a redesign that misses them breaks work nobody wrote down.
- Pick the modernization path on purpose: a reskin, a module-by-module replacement or a full rebuild each fits a different situation and carries a different risk for users.
- Roll out in stages and measure against a baseline: a pilot team, waves with exit criteria, a limited classic-view period and a firm switch-off date turn a launch into an adoption plan.
Enterprise UX Design at a Glance
An enterprise UX project runs in five stages: map stakeholders and sign-offs, audit the legacy system, choose a modernization path, pilot with one team, then roll out in waves and measure. When I read the US Google results for "enterprise ux design" on November 17, 2026, four of the top five results were guides and one was a Reddit thread asking how enterprise UX differs from consumer work. The guides list principles and interface patterns. None of them explains how to handle the people, the old system and the switchover, which is where enterprise projects usually slow down, so this article focuses on those parts.
The screens still matter. The process below is what makes a well-designed interface reach the people who need it. It is also what we look at when we review UX design teams that work on large, long-lived business software.
How Enterprise UX Differs From Consumer UX
Enterprise UX differs from consumer UX in four ways: use is mandated, the buyer and the user are different people, systems live for many years, and success means faster, safer work rather than more time in the product. A shopper who dislikes an app deletes it. A claims handler who dislikes the claims system still opens it at 8 a.m., and finds a workaround if it gets in the way.
| Aspect | Consumer product | Enterprise software |
|---|---|---|
| Who chooses it | The person who uses it | An executive, IT or procurement, on behalf of people who will use it |
| Can users leave? | Yes, in a few taps | No, so dissatisfaction shows up as workarounds, errors and support tickets |
| What success means | Engagement, retention, conversion | Time on task, error rate, completion rate, training time, ticket volume |
| Lifespan | Redesigned often | Often in use for many years, tied to other systems |
| Who can stop a release | The product team | Product, IT, security, legal, procurement and sometimes employee representatives |
One consequence is easy to miss: more time spent in an enterprise tool is usually a bad sign. If people take longer to approve an invoice after a redesign, the new screen is slowing them down, whatever the satisfaction survey says.
Core principles of enterprise UX design
The differences in the table shape how the product should work once people are in it all day. These five principles set the standard for the screens. The rest of this guide covers the people, the legacy system and the rollout.
Design for all-day, every-day use. Employees open these tools at the start of the day and stay in them for hours. Frequent tasks need to be fast and easy to repeat, with consistent layout and wording, because small friction adds up across a full day and a long-lived system.
Role-based access and customization. A power user, an occasional user and a manager do not need the same screen. Match what each role can see and change to their job, and let frequent users adjust defaults and layout without opening access they should not have.
Error prevention over engagement. A missed confirmation or a confusing default can post the wrong invoice or change a record that is hard to undo. Constraints, clear defaults and checks on irreversible actions matter more than features that keep people clicking.
Consumer-grade clarity without consumer patterns. The interface should be as clear as a well-made consumer app, but patterns built for browsing, feeds or engagement often get in the way of focused work. When you need the interface patterns themselves, read our guide to interface patterns for data-heavy work tools that experts use all day.
Contextual research in the real workplace. Meeting-room walkthroughs miss the interruptions, workarounds and side files that shape real use. Watch people in their usual setting, in the live tool, with realistic data, including colleagues who work around the system as well as in it.
Stakeholders: Who Has a Say and What Each Needs
An enterprise UX project usually answers to four groups: those who fund and decide, those who can block a release, the people who use the tool daily, and the people who support the change. Each needs something different from the UX work, and treating them as one audience is the most common reason a good design stalls in review.
Decide and fund
The executive sponsor owns the business case and needs progress reported in business terms: hours saved, errors avoided, a system retired. The budget owner and procurement need a scope they can contract, with clear phases and acceptance criteria. Give them a one-page view of what changes for whom and when, not a design review.
Can block a release
IT and enterprise architecture own the systems your design depends on. If a screen needs data that lives in three systems, they decide whether that is possible this year. Security reviews access, data exposure and session rules. Legal and compliance check retention, audit trails and wording in regulated steps. Bring all of them in before the first prototype, because each can turn a finished design into a rework.
In some countries employee representatives belong in this group too. In Germany, for example, section 87 of the Works Constitution Act gives the works council a right of co-determination over "the introduction and use of technical devices designed to monitor the behaviour or performance of the employees". A new tool that logs who processed what and how fast can fall under that, so check with your legal team early and plan the works council review into the timeline.
Use it daily
Power users know every shortcut and every quirk of the old system, and a redesign takes away their speed for a while. Occasional users open the tool once a month and forget it between visits. Team managers care about throughput and reporting. Design for all three, and recruit research participants from each.
Support the change
Trainers, the help desk and internal champions carry the rollout. They need early access to the new flows, the reasoning behind changes, and a list of what moved where. If they learn about a change on launch day, your users will too.
Turn the list into a sign-off map
A stakeholder list becomes useful when it says who decides, who is consulted and who is informed for each decision, with a date. Maria Rosala of Nielsen Norman Group describes the classic way to rank stakeholders in Stakeholder Analysis for UX Projects: plot them by power and interest, then manage the high-power, high-interest group closely and keep high-power, low-interest people satisfied. In enterprise work I add one column to that map: the specific decision each person signs, such as data access, wording in a regulated step, or the switch-off date. That turns a diagram into a schedule.
Get research access to real users
Research access is often the hardest part of the first month, because managers protect their team's output and IT protects production data. Three things help in a typical project. First, write participation into the project charter with the sponsor's name on it, so a team lead can say yes without asking anyone. Second, ask for short sessions at the desk, in the real tool, with real (masked) data, rather than long lab sessions. Third, include the people who work around the system: the analyst who rebuilds a report in a spreadsheet every Monday knows something the requirements document does not.
Legacy Systems: Audit Before You Redesign
Before any new screen is drawn, audit what the current system actually does, because in long-lived enterprise software many business rules exist only in code, habits and side spreadsheets. A redesign that copies the documented process and misses the rest will break work that people rely on but never wrote down.
In a typical audit, look for six things:
- Hidden business rules: validations, defaults and approval limits that live in the code or the configuration, not in any process document.
- Workarounds: fields used for something they were not designed for, such as a "notes" field that holds a contract number.
- Shadow spreadsheets: exports and side files that people build because the system cannot show what they need.
- Integrations: every system that reads from or writes to the one you are changing, including reports and nightly jobs.
- Roles and permissions: who can see and change what today, and which exceptions were granted by hand.
- Peaks and deadlines: month-end close, payroll runs and seasonal peaks, which decide when you can and cannot change anything.
Watch people work during their real tasks, ask them to show you their spreadsheets, and ask IT for the list of integrations. Then write the findings down as a short inventory. That inventory becomes the test list for the new system: each hidden rule and workaround needs a deliberate decision to keep, replace or drop it.
Choose a modernization path
There are three common ways to modernize an enterprise interface: reskin the existing system, replace it module by module, or rebuild it. The right one depends on how sound the current workflow is, how risky a big switch would be, and how long users can live with two versions.
Reskin. A new interface layer sits on top of the existing back end. It fits when the workflow is sound and the pain is mostly visual: hard-to-read screens, inconsistent controls, poor contrast. It is the fastest path, but it cannot fix a process that needs six screens for a two-step task.
Module by module. New parts replace old ones one workflow at a time, while both run side by side. Martin Fowler named this the Strangler Fig approach, after a vine that slowly grows around its host tree until it can stand on its own. It fits large systems where a single cutover would be too risky. The cost is a period in which users move between old and new screens, so the order of modules matters: start with a workflow that is used often, is painful today and has few integrations.
Full rebuild. A new system replaces the old one in one or a few large steps. It fits when the old platform is no longer supported or the business process itself has changed. It gives the most freedom and carries the most risk, because every hidden rule from the audit must be found and rebuilt before the switch.
If you are still deciding whether a full redesign is needed at all, our guide on when a product needs a complete redesign and when optimization is enough covers that decision.
Rollout: Pilot, Waves, Parallel Run and Switch-Off
An enterprise rollout works best in four steps: a pilot with one team, waves with exit criteria, a limited period in which the old view stays available, and a fixed date to switch the old system off. Launch day is the start of adoption, not the end of the project.
Pilot with one team. Choose a team that does the full workflow, has a manager who supports the change and is not in its busiest month. Watch them work in production for at least one full business cycle, such as a weekly or monthly close, and fix what they find before anyone else switches.
Roll out in waves. Move the next groups by region, business unit or role, and only when the previous wave meets its exit criteria. Waves keep problems small and give trainers time to learn from each group.
Keep a classic view for a limited time. For a module-by-module change, letting users switch back to the old screen for a few weeks reduces risk around deadlines. Make the window clear, ask why people switch back, and treat each reason as a bug or a training gap.
Train in the flow of work. Short in-app notes on changed steps, a "what moved where" page and office hours during each wave do more than a long manual. Recruit one or two champions per team, give them access a few weeks early, and route their questions to the project team.
Switch the old system off on a set date. Agree in advance what has to be true before the old system goes away, then hold to it. Without a date, a parallel run becomes permanent and you pay for two systems.
These are the exit criteria I would put in front of a sponsor for each step:
| Step | Move on when | Who confirms |
|---|---|---|
| Pilot to first wave | Pilot team completes a full business cycle in the new tool; no open issue blocks a core task; time on key tasks is at or near the baseline | Pilot team lead, product owner |
| Wave to next wave | Support tickets per user are falling week over week; trainers and champions report no new recurring question | Help desk lead, training lead |
| Classic view off | Few users still switch back, and every reason they gave has a fix or a workaround | Product owner, UX lead |
| Legacy system off | All integrations and reports run on the new system; data is migrated and checked; legal retention needs are met | IT, compliance, executive sponsor |
Set the numbers behind "near the baseline" and "falling" with your sponsor before the pilot starts. The exact thresholds depend on the task and the team, but agreeing on them early stops the switch-off date from becoming a debate.
Metrics to Agree Before Launch
Agree on four or five task-level metrics before the redesign starts and measure them in the old system first, because without a baseline you cannot show that the new design made work faster or safer. In enterprise software the useful metrics describe work, not attention.
- Time on task for the three to five tasks people do most often.
- Task completion and error rate, including how often work is sent back or corrected.
- Support tickets and how-to questions per user, per week.
- Time to proficiency for a new hire, from first login to working without help.
- Workaround use, such as how many shadow spreadsheets are still needed.
Small time savings add up at enterprise scale. As an illustrative calculation with assumed numbers: if a redesign saves 2 minutes on an invoice approval, a clerk handles 40 invoices a week and 300 clerks use the tool, that is 2 × 40 × 300 = 24,000 minutes, or 400 hours, every week. Replace the assumptions with your own baseline numbers before you put a figure in front of a sponsor.
Working With an Outside UX Team on Enterprise Software
If you bring in an outside UX team for enterprise work, most of the timeline depends on your organization, not on design speed: access to users, security onboarding and sign-off dates. Plan these before the contract starts and the first weeks go to research instead of waiting.
- Access: accounts, VPN, test environments and masked data take time to approve. Start the requests when the contract is signed.
- Research participants: have the sponsor name the teams and dates for the first round of sessions.
- Sign-off calendar: share the dates of architecture boards, security reviews and any works council meetings, and put them in the plan.
- One decision owner: name one person on your side who can settle conflicting feedback within a few days.
- Rollout ownership: agree who writes training material and who supports the pilot, so the design work does not end at handoff.
For the first meeting itself, our kickoff agenda with artifacts and owners for each item lists what to prepare.
Frequently Asked Questions
What is enterprise UX design?
Enterprise UX design is the design of software that organizations use to run their work, such as ERP, CRM, HR, procurement and operations tools. It covers the screens and the process around them: aligning the people who buy, approve and use the software, working with legacy systems, and rolling the new design out to many users.
How is enterprise UX different from B2B SaaS UX?
B2B SaaS is often sold to many companies and can still be dropped by a customer at renewal, so adoption and retention matter a lot. Enterprise software is often configured or built for one organization and mandated for its staff, so the work leans more on internal stakeholders, integrations with existing systems and managed rollout.
How long does an enterprise UX project take?
It depends on the scope, the number of user roles and the modernization path. A reskin of one module can be weeks of work, while a module-by-module replacement of a large system runs over many months or years. In most enterprise projects, sign-offs, access and rollout waves take more calendar time than the design itself.
What is the strangler fig approach?
It is a way to modernize a legacy system by replacing it one part at a time while the old and new parts run together, until the old system can be turned off. The name comes from Martin Fowler, who compared it to a fig vine that grows around a host tree.
Who should own enterprise UX on the client side?
One product owner with authority to settle conflicting feedback, backed by an executive sponsor. Without a single owner, each department reviews the design against its own needs and the project slows down at every review.
Conclusion
Enterprise UX design succeeds or fails mostly around the screens. Map who decides what and by when, audit the legacy system before you redesign it, choose a modernization path that matches the risk you can take, and roll out in stages with clear exit criteria and a firm switch-off date. Measure the old system first, so that when the pilot team works faster with fewer errors, you can prove it. If you plan to bring in outside help for this, the enterprise listing linked at the top of this guide is a good place to start your shortlist.