- An employee cannot leave software the job depends on, so the cost shows up as exports, side spreadsheets and questions to the colleague who knows the trick.
- Dense software is not the problem; unstructured density is.
- For routine actions, prefer undo to a confirmation box.
Enterprise UX design is the design of software people use to do their jobs, across roles, records, approvals and exceptions. In complex workflow software, the principles that matter most are: model the work before the screens, carry context when work changes hands, design the exception path, and judge success by real users finishing real tasks.
This guide gives eight principles, says what kind of evidence stands behind each, and ends with what to look for when you need outside help.
What makes enterprise UX design different from other UX work?
The international standard for usability ties it to three things: specified users, specified goals and a specified context of use. The standard measures the result by effectiveness, efficiency and satisfaction (ISO 9241-11:2018).
A consumer product's users, goals and context can be broad. In enterprise workflow software they are written into the job. A named role owns a record, follows a rule and passes the work to someone else. That is a judgement about why principles for this kind of software concern the work around the screen as much as the screen.
| Consumer product | Enterprise workflow product | |
|---|---|---|
| Who picks it | The person using it | A buyer or administrator, on behalf of the people using it |
| How much it is used | A few minutes, now and then | Most of the working day |
| Who acts on one record | One person, as a rule | Several roles, each with different rights |
| What a confused user does | Leaves, and the loss shows in the funnel | Stays and works around it, out of sight of your analytics |
| What to measure | Sign-ups, activation, retention | Time on frequent tasks, errors, rework and workarounds |
The last two rows explain why enterprise problems go unnoticed. An employee cannot leave software the job depends on, so the cost shows up as exports, side spreadsheets and questions to the colleague who knows the trick. Enterprise UX overlaps with B2B UX, but the two are not the same: B2B covers anything sold to businesses, including tools one person uses alone, while enterprise UX deals with many roles, permissions and approvals inside a larger organisation.
Larry Tesler put the underlying trade-off this way: every application carries an amount of complexity that cannot be removed, and the only question is whether the user, the application developer or the platform developer has to deal with it (Tesler's own statement of the law). Good enterprise UX does not make the complexity vanish. It decides where the complexity sits.
Which principles matter most for complex workflow software?
| Principle | What to check in your product | Kind of support |
|---|---|---|
| 1. Model the work before the screens | Can the team state which records persist, who acts on them and what each status allows next? | Research on how work is actually done, plus design judgement |
| 2. Treat workarounds as evidence | Where do records leave the product: spreadsheets, chat, email? | Information systems research |
| 3. Carry context across every hand-off | Can the next person act without asking what happened? | Adjacent clinical evidence, plus an accessibility standard |
| 4. Make the exception path part of the product | Does each exception show its rule, its evidence and a way to recover? | Adjacent clinical evidence, plus design judgement |
| 5. Keep necessary complexity and organise it | Can a user get an overview, narrow it, reach detail and history, and act on many rows at once? | Information visualisation research, an accessibility standard, plus design judgement |
| 6. Explain permissions and state | Can a user see what they can do, who owns the next step and why access changed? | Practitioner guidance, plus design judgement |
| 7. Make consequential actions recoverable | Can a change to important data be reversed, checked or confirmed? | An accessibility standard |
| 8. Judge by named users doing real tasks | Are success measures tied to specific roles, goals and conditions? | An international standard |
"Design judgement" means a reasoned position, not a research finding. Where the evidence comes from a neighbouring field, the section says so.
How do you apply each principle?
1. Model the work before drawing the screens
A workflow diagram of the happy path is easy to draw and easy to build against. Lucy Suchman's study of people using machines argued that plans are resources people consult, while what they actually do depends on the circumstances in front of them (Plans and Situated Actions, reissued as Human-Machine Reconfigurations). Read for workflow software, that is an inference rather than her finding: the documented flow is a starting point, and the real work includes rules nobody wrote down.
So list the records that persist, how they relate, who can act on each and what each status allows next, before redesigning navigation. Navigation that follows the org chart is one symptom of skipping that step. Mel Conway observed in 1968 that organisations that design systems produce designs that copy their communication structure (How Do Committees Invent?). He wrote about system design, not interfaces, so applying it to menus is also an inference. The same order applies to a component library. Our judgement is that a library built before the role model standardises fragments of screens while the product logic is still undecided.
At Tcules, one published example of our work is Dealpath, where the question was whether a listing already belonged to a deal. We moved the search for an existing deal into the add-listing flow and largely preserved the other listing actions (Dealpath case). We report no measured result in the case, and Dealpath's team owned implementation, so treat it as an illustration of a modelling decision, not proof of an outcome.
2. Treat workarounds as evidence
An approval requested in chat, a customer list exported to compare two teams, a private spreadsheet of exceptions: each shows a part of the job the product stopped supporting. Steven Alter's theory of workarounds describes how and why people create them, and recommends considering likely workarounds during systems analysis and design (Theory of Workarounds, 2014).
Ask users to show the workaround rather than describe it. Then check before removing it. Some workarounds exist because the product lacks a feature; others protect a control that exists for a reason. That caution is judgement, and the research does not settle which kind you have.
3. Carry context across every hand-off
Hospitals are not software, but clinical hand-offs have been studied closely. In a study across nine paediatric residency programmes, a structured hand-off programme was followed by a drop in medical errors from 24.5 to 18.8 per 100 admissions and in preventable adverse events from 4.7 to 3.3 per 100 admissions, with no significant change in measured resident workflow (Starmer et al., New England Journal of Medicine, 2014).
Two limits matter. The programme was a before-and-after intervention that also included handoff and communication training, a faculty development and observation programme and a sustainability campaign, so the improvement cannot be credited to a template alone. And the setting is clinical. What transfers is the structure of what a receiver needs: how urgent the situation is, a summary, an action list, a contingency plan and a check that the receiver understood.
The software equivalent, as a judgement: when a record changes hands, the next person sees its status, what has been done, what is expected and what to do if the normal route fails, without asking. The same logic appears in accessibility guidance: information a person already entered in a multi-step process should be auto-populated or selectable rather than requested again (WCAG 2.2, success criterion 3.3.7). The criterion covers one person within one process; extending it to a hand-off between people is our inference. In our experience, meeting it is a data-model decision before it is a form decision. If a client's details live on a permanent record, every later job and message can read them, and nobody types them twice.
4. Make the exception path part of the product
In B2B workflow software, exceptions are part of the work. Treating each one as a support ticket pushes the cost onto users. Treating each one as an interruption has its own cost. In a retrospective study of 112 primary care clinicians and more than 430,000 patient encounters, the likelihood that a clinician accepted a clinical reminder fell by 30 per cent for each additional reminder received in an encounter (Ancker et al., BMC Medical Informatics and Decision Making, 2017).
The study is observational, covers one electronic health record in community primary care and did not check whether the rejected alerts were the right ones to reject, so it shows a pattern, not a rule for your product. The inference: decide which exceptions deserve an interruption, which deserve a visible state and which need only a recovery path. For each exception, the product should show the rule that applies, the evidence behind it and the next step, rather than a dead end. Interruptions are part of office work too, so a half-finished record should save as a draft and wait safely for the person to come back.
5. Keep necessary complexity, and organise it
Dense software is not the problem; unstructured density is. Ben Shneiderman's 1996 paper proposed a starting point for interfaces to large collections of information: overview first, zoom and filter, then details on demand. It lists seven tasks, including relate, history and extract (The Eyes Have It). Those last three map neatly onto workflow software: related records, a visible history of changes, and a way to take data out.
The paper concerns information visualisation, so applying it to record-heavy business software is an extension. We make a related point about workflow software: a symptom such as too many form fields, inconsistent status labels or dashboard overload may sit in the underlying decisions, states and rules rather than in the surface.
Lists and tables carry much of a daily user's work: the queue, the search results, the records waiting for approval. What to check there, as our judgement rather than a research finding:
- Sorting and filtering on the columns people actually decide by, and search that finds a record by the reference a customer quotes on the phone.
- Column choice: let people show, hide and reorder columns, because a pricing specialist and a sales representative read the same list for different things.
- Saved views: a filtered, sorted list kept under a name, so the morning queue is one click away instead of six.
- Bulk actions: select many rows and act once, with a summary of exactly what will change before it runs. That summary is the review step principle 7 asks for.
- Inline editing for a single field, so changing one value does not mean opening the whole record.
Density is a setting, not a style. SAP's OpenUI5 framework, for example, offers a cozy density sized for touch and a compact one that keeps the text size while shrinking controls and spacing, plus a condensed option for some tables. Generous spacing helps a first visit and taxes the thousandth, so keep text readable and let people choose.
New starters and practised users are always present together, because people keep joining. Ben Shneiderman's golden rules of interface design ask for both: explanations for novices, and shortcuts and faster pacing for experts. Make every action reachable from the keyboard, add shortcuts for the handful of actions people repeat all day, and make them easy to find: on GitHub, typing a question mark lists the shortcuts for the page. Single-key shortcuts need one safeguard. People who dictate can set them off by accident, so WCAG 2.2 (success criterion 2.1.4, character key shortcuts) requires that such a shortcut can be turned off, remapped to include a key such as Ctrl, or limited to when its control has focus.
6. Explain permissions and state, don't only enforce them
Users should be able to see what they can do, who owns the next step and why access changed. When they cannot, they may ask a colleague, and that is hidden work.
The UK government design system advises avoiding disabled buttons where possible, because they have poor contrast and can confuse some users (GOV.UK Design System, Button). That guidance is about form buttons in public services. Extending it to permission-gated actions is an inference: let the person see the action, and when they cannot take it, tell them why and who can. Whether a given reason can be shown is a security decision to make role by role.
Role-based access decides what the system allows; the design decides what each person sees as a result. Beyond the blocked action, two more moments deserve a screen of their own:
- The record is waiting on someone else. Show who holds it and since when, so nobody has to ask in chat.
- The record comes back. Show what changed and why it was returned, next to the fields concerned.
One role is easy to forget: the administrator who sets up roles, fields and approval rules for everyone else. A mistake in configuration reaches every user, so in our judgement these screens deserve the same care as the daily ones, including a preview of which roles and records a change will affect before it is saved.
7. Make consequential actions recoverable
For pages that cause legal commitments or financial transactions, modify or delete user-controllable data, or submit test responses, WCAG 2.2 requires at least one of three safeguards at Level AA: the action is reversible, the data is checked with a chance to correct it, or the person can review and confirm before finalising (success criterion 3.3.4). It is an accessibility minimum for web content, and enterprise software that handles approvals, records and money has reason to aim higher.
Of the three safeguards, reversibility asks the least of the person at the moment of action. Whether a product can offer it depends on its data model and its integrations, which is another reason the modelling in principle 1 comes first.
For routine actions, prefer undo to a confirmation box. A dialogue on every save teaches people to click through it, so it protects nothing by the time it matters. Keep confirmation for what cannot be taken back, such as sending a document to a customer or posting to the accounts, and say exactly what will happen. The cheapest error to recover from is the one never made: before a new record is created, check whether it already exists, because two copies of one deal or client take far longer to untangle than to prevent.
8. Judge by named users doing real tasks
Using the ISO definition above, write down which roles, which goals and which conditions you are designing for, and test representative tasks end to end, including one that hits an exception. Count effectiveness (was the task completed correctly), efficiency (how many steps, retries and manual checks) and satisfaction. A task that finishes after three retries and a message to a colleague has succeeded on a completion metric and failed on efficiency.
How do you tell where your workflow is failing?
Look for these signs in your own product:
- Records are exported to a spreadsheet so another team can compare or hand them over.
- Approvals happen in chat or email because the product cannot represent a substitute approver.
- Support questions are really "where is this, who has it, and why can't I change it."
- Experienced users keep a private list of exceptions.
- Two teams use the same label for different states.
- A recent redesign looked cleaner but left the number of decisions unchanged.
If the cause is disputed inside your company, begin with an audit rather than a redesign. At Tcules, our UX product audit produces findings tied to the workflow and a recommended next step, and our guide to the SaaS UX design audit covers the stages of an audit and what its report contains.
Who should you hire to improve the UX of an enterprise workflow application?
It depends on where the problem sits. In-house designers who know the domain already have the context. Outside help makes more sense when the product model is disputed, when the team lacks capacity, or when design has to carry through into implementation. When the need is continuous, the useful question is who owns product decisions and who holds the context; the guide to outsourcing UX design compares the ways to arrange that. In every case, the questions below separate someone who will redraw screens from someone who will fix the workflow.
- Do they ask to follow one record through every role before proposing screens?
- Do they ask for access to the people who know the exceptions, not only the people who commissioned the work?
- Can they show a model from past work (records, roles, states, exception paths) and not only finished screens?
- Do their case studies say what they contributed, how far implementation went and which results were never measured?
- Do they plan for existing users: learned terminology, saved views, links and a way back if the transition fails?
- Can they carry design intent into the build, or does it get lost in a hand-off?
For complex workflow software, our approach is to model the workflow before redesigning it: what persists, who may see and change it, which rules move it and which exceptions matter. Our information architecture and workflow design work produces that model: object and relationship model, role and permission decisions, lifecycle and exception paths, and proposed navigation. What your team receives, and who needs to be available, is on our B2B SaaS and workflow software page. When the need is continuous, a senior designer leads it, does the design and talks to you without a go-between, and specialists join when a problem calls for them (how we work).
We are the wrong choice for rate-led production outsourcing, for a request to decorate screens while workflow behaviour is out of scope, and where there is no access to the people or materials that explain the operating work. This article is written by our founder, so weigh the fit question accordingly.
This problem sits between design, product and engineering
Enterprise workflow UX can sit between design, product and engineering. For adjacent questions, see CPQ UX design for one specific workflow domain and rebuild or modernise legacy software when the product is old rather than merely hard to use.
About the authors
Yash Gidwani
Product Designer
Yash Gidwani is a Product Designer at Tcules, the digital product design studio in Ahmedabad. At Tcules, Yash works on onboarding and engagement and on enterprise workflow software, and writes about questions such as why new accounts sign up but do not get going, how to redesign legacy software without upsetting its users, and how to stop duplicate records. The pieces below speak for the studio, and this page grows as Yash writes.

Rushali Bhatt
Product Designer
Rushali Bhatt is a Product Designer at Tcules, the digital product design studio in Ahmedabad. At Tcules, Rushali works on AI product UX and UX research, and writes about questions such as where the human check belongs in an AI feature, how to run usability studies on complex enterprise software, and what a heuristic evaluation should deliver. The pieces below speak for the studio, and this page grows as Rushali writes.