Book a call

WritingBuilding a systemPart 2 of 3 in Building one

How to run a design system audit (with an interface inventory method)

An audit shows you what you really have: how many buttons, how many blues, which screens drift. Done well, it ends in a ranked plan and a number leadership understands. Here's the method, step by step.

On this pageWhat is a design system audit?
  1. What is a design system audit?
  2. What you'll need
  3. The audit, step by step
  4. What a good audit report contains
  5. Turning the audit into a business case
  6. Common audit mistakes
  7. The short version
  8. Frequently asked questions
  9. Further reading

The short answer

A design system audit (or interface inventory) is a structured look at everything your product's interface is made of: every button, input, message, colour, text style and spacing value, in design files and in code. You screenshot it, group near-duplicates, count the variations, check accessibility, and rank what to fix first. Done well, it takes about two weeks and ends in a ranked plan and a handful of "before" numbers leadership understands.

  • Audit 15–25 key screens across every product and platform; you don't need every screen to see the pattern.
  • Count in code as well as design. The code is where the real duplication lives.
  • Run it with designers and engineers together. People who find the seven buttons themselves become the system's supporters.

What is a design system audit?

An audit answers one question: what do we actually have? Not what the style guide says, not what the Figma library contains, but what's live in production and in the code that builds it.

Brad Frost popularised the method as an interface inventory in 2013: screenshot every instance of every interface element, group them by type, and look at them side by side. The differences jump out immediately. We extend it in two directions that matter for planning a design system: counting what's in the code, and turning what you find into a ranked plan.

You need an audit when you're about to start a design system, when an existing one has lost trust, before a rebrand or dark mode, or when you need to make the case for investment. It's also the first thing we do in any engagement, because every later decision depends on it.

What you'll need

PEOPLE

One or two designers and one engineer for most of two weeks, plus an hour each from product leads for the walkthrough. Ideally someone who can run accessibility checks.

ACCESS

Production (and staging) for every product and platform in scope, the main design files, and read access to the front-end repositories.

TOOLS

A shared board (FigJam, Miro or a Figma page), a spreadsheet for counts, a code search tool, and a browser accessibility checker.

The audit, step by step

1 · ScopePick 15–25 screens
→
2 · CaptureScreenshot by category
→
3 · GroupNear-duplicates side by side
→
4 · CountDesign and code
→
5 · CheckAccessibility and foundations
→
6 · RankFrequency × pain
→
7 · ShareWalk people through it
Seven steps over about two weeks. Steps 2–5 can run in parallel between designers and engineers.

Step 1: Pick your scope

Choose the 15–25 screens that matter most, by traffic, revenue or importance, across every product and platform: web, mobile web, iOS, Android, admin tools. Include at least one form-heavy flow, one data-heavy screen (a table or dashboard) and one empty or error state. These are where inconsistency hides.

Step 2: Capture everything, by category

Screenshot every instance of each kind of element and paste them onto one board per category. Categories that almost always reveal something:

Actions

Buttons, links, icon buttons, menus

Inputs

Text fields, selects, checkboxes, radios, toggles, date pickers

Feedback

Alerts, toasts, inline errors, empty states, loaders

Containers

Cards, dialogs, drawers, tabs, accordions

Data

Tables, lists, badges, tags, charts

Navigation

Headers, side navigation, breadcrumbs, pagination

Foundations

Colours, text styles, spacing, radii, shadows, icons

Content

Button labels, error messages, dates, numbers

Step 3: Group the near-duplicates

Within each board, put things that are meant to be the same next to each other. Five primary buttons with slightly different heights, radii and blues; four ways to show an error; three date pickers. Don't judge yet, just group. The visual comparison does the persuading for you.

Step 4: Count, in design and in code

This is the step most audits skip, and the one that makes yours useful. For each category, record:

  • How many different versions exist in production.
  • How many implementations exist in code: separate button components, separate modal components, copy-pasted variants.
  • How many raw values are in the code: search the repositories for hex codes, rgb() values and pixel sizes typed directly into styles.
  • How often each component is used: count imports or instances in code and in design files.
# Rough but useful: distinct hex colours in the front-end code
grep -rhoiE '#[0-9a-f]{6}\b|#[0-9a-f]{3}\b' src/ | tr 'A-F' 'a-f' | sort | uniq -c | sort -rn | head -40

# How many different button components exist?
grep -rlE '(export (default )?function|const) \w*Button\b' src/ | wc -l

These counts are imperfect, and that's fine. You're looking for orders of magnitude: "eleven border greys" and "four modal implementations" are what leadership remembers.

Step 5: Check accessibility and foundations

Run an automated checker on each screen in scope and record the issues by type. Then check the foundations directly:

  • Text and background pairs meet WCAG 2.2 contrast: 4.5:1 for body text, 3:1 for large text, borders and focus indicators.
  • Every interactive element shows a visible focus state and can be reached with a keyboard.
  • Form fields have visible labels, and errors say what went wrong and how to fix it.
  • Touch targets are at least 24 by 24 CSS pixels (WCAG 2.2, 2.5.8), and ideally 44 or more on mobile.
  • Text still works when users enlarge it to 200% and increase line and letter spacing.

Accessibility issues found in shared-looking components are the strongest argument for a design system: fix them once in the system, and they're fixed everywhere it's used. WebAIM's 2025 scan found low-contrast text on 79.1% of the top million home pages, so expect to find some.

Step 6: Rank what to fix first

Now combine two pieces of information for each component: how often it's used, and how much trouble it causes (versions, bugs, accessibility issues, time spent rebuilding or debating it).

more trouble ↑
Plan nextPainful but rare: date picker, file upload
Build firstUsed everywhere and inconsistent: button, field, select, alert, dialog
Leave aloneRare and fine: keep local until a second team needs it
Quick tidyUsed everywhere, mostly fine: links, badges, avatars
used more often →
The audit's main output: a ranked list. Top right first. Most teams' first ten components land there.

Step 7: Share it, in person

Walk leadership and product teams through the boards. Don't send a PDF. Seeing seven primary buttons on one wall is the fastest way to build shared understanding, and it's when people start asking "so what do we do?", which is exactly the question you want.

What a good audit report contains

Keep it short. The boards do the persuading; the report records the decisions.

1 · THE NUMBERS

Five or six headline counts: button versions, raw colour values, modal implementations, accessibility issues by severity, text styles in use.

2 · THE BOARDS

One image per category showing the near-duplicates side by side.

3 · THE RANKING

Every component plotted on the 2×2, with the first ten to build named.

4 · THE PLAN

What to do in the next 90 days: foundations, first components, pilot team, owner. With rough effort in FTE-weeks.

11border greys
7primary buttons
5text field styles
4ways to show an error

Example headline numbers from a fictional audit. Illustration Your numbers will differ; their shape usually won't.

Turning the audit into a business case

Counts become a business case when you connect them to time and risk. Three simple translations work well:

  1. Duplication → maintenance cost

    Four modal implementations means four places to fix every bug and four to update in a rebrand. Ask engineers how long the last cross-cutting change took.

  2. Accessibility issues → risk

    If you sell to enterprises or the public sector, or operate in the EU under the European Accessibility Act, issues in shared components are a compliance exposure, not just a quality problem.

  3. Raw values → change cost

    Hundreds of hard-coded colours means a rebrand or dark mode is a rewrite. Tokens turn it into a configuration change. See design tokens.

Be careful with speed claims. Published studies show real gains on specific tasks, but they're best cases. We've written an honest model, with break-even points by team size, in design system ROI.

Common audit mistakes

Auditing only Figma

Design files show intentions. Production and code show reality. The gap between them is often the most important finding.

Auditing every screen

You'll spend weeks and learn little more than you would from 20 well-chosen screens.

Doing it alone

A solo audit produces a report people feel judged by. A team audit produces supporters.

Stopping at the inventory

Boards without a ranking and a 90-day plan are interesting, not useful. Always end with what to build first.

The short version

  • Scope 15–25 key screens; capture every element by category; group near-duplicates.
  • Count in code as well as design: versions, implementations, raw values, usage.
  • Check accessibility and foundations; issues in shared components are the strongest case for a system.
  • Rank by frequency × trouble; build the top-right components first.
  • Share it in person, as a team, and end with a 90-day plan.

Frequently asked questions

How long does a UI audit take?

About two weeks for most product companies with one to three products, with one or two designers and an engineer. A single-product startup can do a lighter version in a few days.

Who should be involved?

Designers and engineers together, with product leads joining for the walkthrough. Engineers are essential for the code counts, which are often the most revealing numbers.

Can a design system audit be automated?

Parts of it. Code searches for raw values, import counts, Figma library analytics and automated accessibility checkers all help. Grouping near-duplicates and ranking them still needs people.

What's the difference between a UX audit and a UI audit?

A UX audit looks at whether people can complete their tasks: flows, findability, friction. A UI or design system audit looks at what the interface is made of and how consistent it is. They complement each other.

How often should we audit?

A full audit before starting or restarting a system, then a lighter check every quarter: raw values, detached components and new one-off patterns.

Further reading