UX Audit: What It Evaluates and How to Run One

What a UX audit is — and what it is not

The core of a UX audit is task completion. A visitor arrives with a goal: buy the thing, get a quote, book the appointment. The audit walks that path deliberately, on desktop and on a phone, and documents every point of friction — the confusing label, the form that scolds instead of helps, the mobile menu that hides the one link that matters.

That distinction matters because a lot of things get sold as UX audits that aren't. A performance report tells you how fast pages load, not whether anyone can complete a purchase. An analytics review tells you where people drop off, but not why. A real UX audit produces specific, evidence-backed findings tied to specific screens: this element, on this page, causes this problem, and here is the fix.

The output should be actionable without translation. If an audit ends with "improve the user experience", it failed. If it ends with a ranked list of concrete fixes you could hand to a developer, it worked.

What a UX audit evaluates

Scope varies by site, but a serious audit covers five territories. Skip any of them and you leave blind spots exactly where visitors get stuck.

• Navigation and findability. Can a first-time visitor tell where they are, what this site offers, and how to get to the thing they want? Are menu labels written in the visitor's language or the company's internal vocabulary?
• Task flows. The end-to-end paths that matter commercially: browse to checkout, landing page to quote request, search to contact. How many steps does each take, and does any step introduce doubt, surprise costs, or unnecessary questions?
• Mobile usability. Not just "does it render" — are tap targets big enough, does the keyboard match the field (numeric for phone numbers), do sticky headers eat half the screen, does anything overlap on a real device width?
• Forms. Usually the highest-friction point on any site. Field count, label clarity, error messages that explain the fix, whether progress survives a validation failure, and whether anything is asked for that isn't needed.
• Feedback states. What the site does after the visitor acts. Loading indicators, success confirmations, empty states, error pages. Silence after a click is one of the fastest ways to lose trust — people assume broken, and leave.

Heuristic frameworks, in plain language

Most professional audits use heuristic evaluation: judging an interface against a checklist of well-established usability principles rather than pure personal taste. The best-known set is Jakob Nielsen's ten usability heuristics, which have held up since the 1990s because they describe how people think, not how technology works. You don't need the academic phrasing. Here is what the ones that matter most for commercial sites actually mean.

Show system status: if a form is submitting, show it submitting. Speak the customer's language: "Pricing", not "Commercial Solutions". Give people control: let them go back and fix mistakes without starting over. Stay consistent: the same action should look and behave the same everywhere. Prevent errors instead of reporting them: a date picker beats an invalid-date message. Favor recognition over recall: don't make people remember a previous screen — show the information again. And keep pages minimal: every extra element competes with the one action you want taken.

The value of a framework is not the list itself. It's that a checklist forces you to look at parts of the experience you'd otherwise skip because you personally never use them. Founders test the happy path. Frameworks make you test the unhappy ones.

How to run a lightweight UX audit yourself

You can get a meaningful fraction of a professional audit's value in a few focused hours. The discipline that makes it work: behave like a stranger, and write everything down as you go.

• Define the one task that matters. Not ten tasks — the primary journey your business depends on. For a store, complete a checkout to the payment step. For a service business, submit a quote or booking request.
• Open the site in a private browser window on a device you don't normally use, ideally a phone. Private mode kills your cached sessions and saved form data — the crutches that hide first-visit friction.
• Run the five-second test on your homepage: look for five seconds, look away, and say aloud what the site offers and for whom. If you hesitate, strangers are lost.
• Attempt the task start to finish and note every hesitation. Every moment you had to think about what to do next is a finding. Screenshot each one; a finding without a screenshot gets argued with, a finding with one gets fixed.
• Deliberately break things. Submit the form empty. Enter a malformed email. Hit back mid-checkout. Watch what the site does — this is where feedback states and error handling either hold up or collapse.
• Score each finding on two axes: how much it hurts the primary task, and how hard it is to fix. Fix high-damage, low-effort items first. A vague "redesign someday" list helps nobody.

The blind spot no self-audit escapes

Here is the honest limitation of auditing your own site: you cannot un-know it. You know the menu label "Solutions" means services because you wrote it. You know the checkout works because you've tested it forty times — always the same way, on the same machine, with the same autofilled details. Familiarity doesn't just bias your judgment; it edits what you're capable of noticing. This is why usability professionals put such weight on fresh eyes.

The classic fixes are user testing sessions — watching a handful of real people attempt tasks — and hiring a consultant for a heuristic review. Both work. Both cost either meaningful money or meaningful organizational effort, which is why most small-business sites iterate for years without either one happening.

Where automated journey testing fits

A newer middle option is having an AI attempt your site's customer journey the way a person would. This is different from grader-style tools, which run code and performance checks against a URL — useful for technical health, but structurally incapable of telling you whether a human can complete your checkout, because they never try. Automated journey testing does try: an agent loads the site in a real browser, reads the pages like a first-time visitor, and works through the primary task, recording where it gets confused or blocked.

This is what ExperienceGrade does. You enter a URL, and an AI customer tests the site in a real browser — desktop and mobile, up to five key pages — and attempts the primary customer journey, like starting a checkout or submitting a quote request. The report covers six scored areas including usability and mobile, conversion path, and clarity, with evidence-backed findings, annotated screenshots, exact copy rewrites for weak headlines and CTAs, and a prioritized action plan. You can see the full format in a real sample report at /sample-report before deciding whether it's worth running on your own site.

The fair framing: an AI tester is not a replacement for watching real customers. What it replaces is the nothing most sites currently get — an unfamiliar visitor's perspective, on demand, with screenshots, in about 10 to 15 minutes. Use it as the fast first pass; save human testing for validating big changes.

What to do after the audit

An audit that doesn't change the site was a reading exercise. Work the ranked list top-down: high-damage, low-effort fixes first — in practice, copy changes, form-field removals, error-message rewrites, and mobile tap-target fixes, not redesigns. Most friction is embarrassingly cheap to remove once someone has actually named it.

Then re-test. Fixes have a habit of introducing their own friction, and a checkout that worked before a template update may quietly break after one. Whether you re-run your own walkthrough each quarter or use a tool with built-in retests, the audit is a loop, not an event. ExperienceGrade's $49.99 option includes three retests over 90 days for exactly this reason; the $29.99 single audit is one-time either way, with no subscription. Put the re-check on a calendar. Entropy always wins against sites nobody re-tests.