Book a call
All writing

How to run a UX audit that leads to useful fixes

A UX audit follows real tasks through your product, records where people get stuck and ranks fixes by user impact, evidence and the effort required.

A UX audit is a structured review of how well a product helps people complete their tasks. A useful audit combines a walkthrough of the interface with available usage evidence, then turns the findings into a prioritised set of changes. Its value is in the decisions it enables.

Start with one important journey. “Review the app” gives you an endless list of observations. “Find out why new account owners cannot finish setup” gives the work a boundary. You can still record problems outside that boundary, but they should not displace the question the audit was commissioned to answer.

The work runs in a fixed order. Each step is listed here with what it produces, because the next step depends on it.

  1. Write the task as an outcome: one sentence naming the people involved, where they start and what counts as finished.
  2. Collect the evidence and prepare test accounts: a short evidence file and a set of accounts in the states your customers are in.
  3. Walk the task through the checks: a result for every check, with a link to the evidence.
  4. Write each issue as a finding: one record per problem that someone else can reproduce.
  5. Rank the findings with the engineers: a short ordered list with reasons, an owner and a way to verify each fix.
  6. Make the first change and run the task again: a before and an after that mean the same thing.

1. When is a UX audit the wrong first step?

An audit reviews a product that exists and a task people already attempt. We’d start somewhere else in four situations.

  • The problem is a known defect. Fix it and check the result.
  • The flow is about to be replaced, or does not exist yet. Prototype the new flow and test that.
  • Nobody can name the task or the people who do it. Agree those first, because without them the audit becomes a list of opinions about screens.
  • You need to show that the product meets an accessibility standard. Commission an accessibility assessment against that standard.

An audit is also limited when you have no access to users or usage data. An expert review can still find problems, but every explanation in it is a hypothesis, and the report should say so.

2. What should you collect before reviewing the interface?

  • The task and the people who need to complete it.
  • The intended success event and the current steps leading to it.
  • Support themes, known defects and customer feedback.
  • Available funnel data, including the period and audience it represents.
  • Representative accounts: new, established, empty and unusually complex.
  • Technical or commercial constraints that a proposed fix must respect.

Write the task as an outcome before you open the product. For example: “A new finance manager needs to review last month’s invoices and send the approved batch for payment.” Name the people involved, where they start and what counts as finished, and use a task your customers do.

Then prepare the test accounts. Use safe test data that keeps the complexity of real work: long names, old records, multiple teams and incomplete information. Write down anything the test environment cannot reproduce, because a check you could not run is different from a check that passed. Each account state lets you examine something the others hide.

  • A new member with no records: the first action, the explanations and access requests.
  • An established member with many records: search, filtering, bulk work and history.
  • A restricted role: visibility, permission boundaries and escalation.
  • An administrator: setup, invitations, ownership and team changes.
  • An interrupted workflow: unsaved work, expired sessions and recovery.

Keep observation separate from explanation. Analytics may show a drop between two steps without telling you why people left. A reviewer may find a confusing label without knowing whether it affects many users. Record both, then identify the research or instrumentation needed to connect them. Do not dress an expert opinion up as something users demonstrated.

On Lumos, an out-of-home media planning platform, the two came from separate steps. We audited the planning and buying tool end to end, every screen, state and workflow, to understand what had been built, where planners dropped out and which parts were carrying the most load. That gave us a backlog of friction points we could test against the internal team’s own experience. We then spent time with planners, traders, engineers and the people fielding client questions, who helped us work out why the product behaved the way it did and which constraints were real. The audit told us where the old product broke down and the interviews told us why, so the task flows that followed started from evidence.

The scope there was a whole tool because the work was to rebuild how planners buy, which is wider than the single journey we’d recommend for a first audit. Even with that evidence, the flows went through a lot of rounds, and almost every version we put in front of the team came back with something we had assumed wrong. That is the reason to label an explanation as a hypothesis until someone who does the job has checked it. On Lumos we designed the screens, the component library and the specifications, and the engineering team built from them.

3. How do you walk through the product?

Use the product as a person with a job to finish. Begin where they would begin, with the information they would have. Follow the main path and then the likely interruptions: missing data, a validation error, an expired session, a return visit and a smaller screen. Check whether the product explains what happened and how to recover.

A workflow can be technically complete and still leave someone uncertain. Does “Save” mean a draft or a published change? Has an invitation actually been sent? Can someone undo a decision? These are often more useful audit questions than whether a card has the latest visual treatment.

Where possible, watch representative users attempt the task. GOV.UK’s moderated usability-testing guidance describes observing participants complete specific tasks to identify usability problems. Keep the task neutral: asking someone to “click the settings icon” tests obedience to an instruction, not whether they can find the account controls.

Record a result for each check as you go: pass, issue, untested or not applicable, with a link to the evidence. A tick without a tested account and task is difficult for the next person to trust. “Untested” is a useful result, because it tells the team which parts of the task the audit has no view on.

4. What should you check on the walkthrough?

The checks below are written for a SaaS product and one workflow. They follow the order in which a person meets the product: getting in, finding the work, acting on data, handing over to someone else and recovering when something fails. The last group covers access and testing with people. Mark any check that does not fit your task as not applicable and move on.

Start with entry and setup. A person who cannot get into the account never reaches the task you are auditing.

  • Invitations lead somewhere useful. Test a valid invitation, an expired one and a link opened while signed in to a different account. The person should be able to recover without contacting support.
  • Setup asks for information at the right time. Identify which fields are essential for the first task and which can wait, and check whether the product explains unfamiliar terms.
  • An empty account offers a relevant next action. Someone should be able to tell whether they need to create a record, connect a source or ask a colleague for access.
  • Returning users can resume. Leave midway through setup, sign out and come back. Check what survives and whether the remaining work is clear.

Next comes navigation and account context. These checks show whether people know where they are before they change something.

  • The current workspace is obvious. Check that the organisation, project and environment are visible before a change is made, particularly when users belong to several accounts.
  • The task can be found from a realistic entry point. Start from an email link or a saved record as well as the dashboard, and note which labels need insider knowledge.
  • Search and filters explain the result. Try no matches, several filters and a cleared search. “No records exist” should be distinguishable from “nothing matches”.
  • Back and refresh keep sensible context. Open a record, return to the list and reload. Check whether filters, selection and scroll position support the next step.

The third group is data and consequential actions: the points where someone approves, exports or changes many records at once.

  • People can inspect what they are acting on. Include long values, missing fields and large datasets, and check whether truncation hides information needed for a decision.
  • Units and dates are unambiguous. Review currency, timezone, reporting period and totals at the point where someone approves or exports work.
  • Bulk actions state their scope. It should be clear whether a selection includes the visible page, the filtered results or every record. Check the result when some items cannot be changed.
  • Completion means something specific. A saved draft, a queued job and a finished operation are different states. Check that the interface reports a failure that happens after the first request was accepted.

Roles and handovers come fourth, because work in a SaaS product often passes between people. Managed, a property platform we designed the identity for, puts renters, owners, agencies and tradespeople in one place. A product with that many roles needs each of them in the audit.

  • Restricted actions explain the next step. A disabled control should help someone understand the requirement or who can help, where that is appropriate.
  • Role changes behave consistently. Review the workflow after access is granted or removed. Interface checks should be accompanied by engineering verification that access is enforced on the server.
  • Handovers identify the owner and the state. Check whether a requester knows who must act next, what that person received and whether a reminder or reassignment is possible.
  • Concurrent work has a clear outcome. Have two test users edit the same record. Look for overwritten work, stale status and unclear conflict recovery.

Failure and recovery is the fifth group. It needs a controlled test environment and an engineer nearby, because some of these checks interrupt a save on purpose.

  • Validation preserves useful input. Submit an incomplete form and correct it. Errors should identify the problem without making the person repeat unrelated work.
  • Connection failures have a recoverable state. Interrupt a save or upload in the test environment and check whether the person can tell what reached the server.
  • Retries avoid accidental repetition. Review double clicks, delayed responses and retried jobs with engineering. A reassuring spinner does not establish that the operation is safe to repeat.
  • Destructive actions communicate consequences. Check what will be affected, who else depends on it and what recovery is available.

Finish with access and testing with people. The access checks here are preliminary and do not replace a complete accessibility assessment.

  • The task works with a keyboard. Check focus visibility, focus order and escape from dialogs.
  • Content remains usable when enlarged. Review headings, contrast, labels and errors as well as text size.
  • Representative users attempt the task. Give them the outcome without naming the controls to click.
  • Findings distinguish observation from explanation. Record what happened, how often it was seen and what remains uncertain. A support complaint, an analytics event and a reviewer’s hypothesis are different forms of evidence.

5. What belongs in each finding?

  • The screen or step where the problem occurs.
  • What happened, with a screenshot or reproducible example.
  • Who it affects and which task it interrupts.
  • The evidence available and how confident you are in the explanation.
  • A proposed change or the next question to investigate.
  • Dependencies, an owner and a way to check the result.

For example, a useful finding might say that invited users reach an empty workspace without knowing how to request access. The proposed fix could include clearer invitation status and a recovery action. “Improve onboarding” is too broad to estimate, assign or verify.

Here is one finding written out in full. The example is made up to show the level of detail. It is not a result from a client audit.

  • Task and role: a finance manager submits an approved invoice batch.
  • Observation: a partial failure produces “Complete”, while three invoices remain unsent.
  • Evidence: reproduced in the test account, with a recording and the affected record IDs attached.
  • Consequence: the manager may believe suppliers have been paid.
  • Confidence: the behaviour is confirmed. How often it happens in production is unknown.
  • Next action: show the partial outcome and a safe retry for the failed items, and inspect production error counts.
  • Acceptance check: the user can identify the failed items and retry them without resending the successful ones.

Write the acceptance check before anyone designs the fix. It gives an engineer something to estimate and a reviewer something to verify, and it stops the fix growing into a larger redesign.

6. How should you prioritise the fixes?

Consider the consequence for the user, how often the situation occurs and the strength of the evidence. Then consider delivery effort and dependencies with the engineers. A severe problem can deserve attention even when it affects a small group. An easy cosmetic change should not automatically outrank a task that cannot be completed.

Avoid turning uncertain estimates into a false scientific score. A short ordered list with reasons is often more useful. Separate confirmed defects, promising design changes and questions that need research. Each calls for a different next step.

  • Confirmed defects go to the engineers with the reproduction steps and the acceptance check.
  • Promising design changes go into a prototype, so the interaction can be tested before the full build.
  • Open questions go to research or instrumentation, with a note of the evidence that would settle them.

Assign an owner and a verification step to the first few findings and leave the rest ranked. The cost of a short list is that some real problems wait for the next round. We’d accept that in exchange for findings that each have a person responsible for them.

7. What we saw on Keeyu

Keeyu helps large retailers manage everything that can go wrong after an order is placed. Its product has to handle multiple brands, sales channels, integrations and operational workflows, often all at once. We were embedded in Keeyu’s team and designed from the real product, working closely with their product and engineering team. Our part was design, and Keeyu’s own team built the product.

The problem we started from is the kind an audit records. The complexity was necessary, but it was not always clear to the people using it. Important setup and operational work could feel fragmented, and the product did not always show customers where they were, what mattered or what to do next. In the terms of the checks above, they are problems of context and of the next action. The case study describes them at the level of the whole product, across setup and operational work.

A finding like that can be answered one screen at a time. On Keeyu the work was less about redesigning individual features and more about establishing a clearer way for the product to work as a whole. We looked for the common patterns underneath different workflows: how progress is shown, how related information is grouped, how guidance appears, and how people move between tasks without losing context. That gave us a set of shared building blocks, so the team had clearer decisions to build from as new parts of the product took shape.

The decision was then checked with the people who had to build it. We brought ideas into regular reviews, tested them against real constraints and adjusted them with the people responsible for building the product. The case study says this made the design more practical and stopped polish from getting ahead of what the product needed.

That is where the record stops. The case study does not call this work an audit, and it does not list individual findings, the evidence behind each one or the order they were dealt with. It reports no completion rate, support figure or other before and after measure, so we make no claim about one. What it does show is an observed problem, stated plainly, becoming a design decision the team could build from. Lan has written a separate account of the project on this blog, and our studio notes on Keeyu keep the project facts apart from the general recommendations.

We’d carry one thing from it into any audit. When the same problem turns up in setup and again in daily operations, write it once as a finding about the pattern and propose a change to the pattern.

8. What happens after the audit?

Take the highest-priority flow into a prototype or a small implementation. Check the change against the original problem, then observe the released behaviour. A task-completion measure, support theme or recovery rate may be more useful than a general satisfaction question. Use a consistent definition so the before and after mean the same thing.

Refract’s product sprint is designed for this handover from diagnosis into a working direction. We audit the flow, prototype it on real content and test it with users before setting out the build plan. If the audit already identifies a straightforward defect, fix it rather than inventing a workshop around it.

A UX audit can also be the whole engagement: a focused review with prioritised findings, evidence and the next changes to investigate. Either way the scope and price are agreed upfront. Bring a product link, one difficult journey and the decision your team needs to make.

9. Questions

  1. No. An expert review examines the product; user research observes or asks the people who use it. They can inform each other, but an audit should clearly identify which findings came from user evidence.

  2. It should consider keyboard use, readable content, focus and other access barriers. A general UX audit is not a substitute for a defined accessibility assessment with an agreed standard and appropriate user testing.

  3. Scope the task end to end rather than choosing an arbitrary screen count. Include the important entry, success, failure and recovery states for that task.

  4. Follow one task through six groups of checks: entry and setup, navigation and account context, data and consequential actions, roles and handovers, failure and recovery, and access and testing with people. Record each check as pass, issue, untested or not applicable, with a link to the evidence.

  5. A short ordered list of findings with reasons. Each finding names the task and role, what was observed, the evidence, the consequence, how confident you are in the explanation, the next action and an acceptance check. The first few findings also have an owner and a verification step.

  6. When the problem is a known defect, when the flow is about to be replaced or does not exist yet, when nobody can name the task, or when you need an assessment against an accessibility standard. Fix the defect, prototype the new flow, agree the task or commission the accessibility assessment instead.

Sources and further reading

Written on by Naiya Sarisha ZahwaProduct DesignerNaiya Sarisha Zahwa on LinkedIn

Keep reading

Working on something like this?

Tell us where it’s stuck. We’ll tell you what we’d do first, and whether we’re the right team.

Most teams start with a call, then a sprint or an audit.

Book a call
  • Angus
  • James
  • Naiya
  • Lilian
  • Luca
  • Minh
  • Jorge
  • Toffee

The people you’d work with, from the first call to launch