Onboarding redesigns usually start from a feeling. Activation looks disappointing, somebody watched a session recording that was painful, a competitor shipped something nice — and the team commits to rebuilding the flow. Three months later there is a new flow, a modest bump that could be seasonality, and no clear account of what was wrong with the old one.
An audit is the cheap step that makes the expensive step worth taking. It costs about a week and produces something a redesign cannot start without: a ranked list of specific findings, each attached to a step, a segment and a number.
Key Takeaways
- An audit is diagnosis, not design — the output is findings, not a new flow.
- Walk the flow yourself in a fresh account. Most findings come from this, not from dashboards.
- Audit five layers, not just the middle one — the promise before signup is part of onboarding.
- Test the invited-member path too. It is usually half your new users and never gets tested.
- Score findings by impact over effort; the list splits cleanly into "product must change" and "product must explain".
- The explaining half is typically larger and can ship in days rather than quarters.
- A week is the right budget. If it runs a month, it has become a redesign in disguise.
What Is a User Onboarding Audit?
User onboarding audit (definition): a structured review of everything that happens between signup and a user's first real result, carried out against a fixed checklist and real behavioural evidence, producing a ranked list of specific, defensible findings.
The discipline that makes an audit useful is the refusal to propose solutions while doing it. The moment the team starts designing the fix, evidence-gathering stops — and the findings that would have justified a different fix never get collected. Write findings only: "41% of new admins abandon on the workspace-creation screen; the required field 'billing entity' is not needed until the first invoice." That is a finding. "We should simplify the workspace screen" is a solution, and it belongs in the next meeting, not this one.
Audit vs. teardown vs. redesign
| Input | Output | Typical length | |
|---|---|---|---|
| Audit | Your own product, your own data | Ranked findings with evidence | About a week |
| Teardown | Someone else's product, no data | Opinions and inspiration | An afternoon |
| Redesign | The audit's findings | A new flow | Weeks to months |
Teardowns of other companies' onboarding are entertaining and occasionally instructive — see these onboarding examples — but they cannot tell you what is wrong with yours, because they contain no evidence about your users.
When to Run One
-
Activation is flat or falling
Two months of no movement in activation rate is a signal, not noise — especially if signups are growing.
-
Before a redesign is committed
The cheapest week you will ever spend. It decides whether the rebuild is aimed at the real problem.
-
After the product, pricing or audience changed
Onboarding built for the previous version stops fitting quietly. Nothing breaks; it just gradually stops matching who is signing up.
-
Support keeps answering the same first-week questions
A repeated week-one ticket is onboarding failing with a price tag attached.
When not to run one. If you already know the finding and simply have not fixed it, an audit is procrastination with a deliverable. And if there is no capacity to act on the results for the next quarter, wait — an audit that produces a document nobody actions makes the next one harder to justify.
The Five Layers to Audit
Most audits examine the middle of this list and miss the ends, which is where a surprising share of the cause lives. Onboarding starts before the signup button and does not finish until someone can tell you which step is losing people.
Illustrative scorecard shape, not benchmark data — the pattern worth noticing is that layers 3 and 5 are almost always the weakest, and almost never the ones a redesign starts with.
Layer five is the one teams skip and then regret. If nobody can say which step loses the most users, the audit is running on impressions — and every subsequent argument about priorities will be settled by seniority rather than evidence.
How to Run a User Onboarding Audit in 8 Steps
- Define what "onboarded" means, in one sentence
- Gather the evidence you already have
- Walk the flow as a genuinely new user
- Walk it again as an invited member
- Work through the checklist, layer by layer
- Write findings, never solutions
- Score and rank
- Split the list and start with the cheap half
1. Define what "onboarded" means, in one sentence
Pick the single observable action that means a user got real value — not "logged in twice", but something like "imported data and ran one report". Everything in the audit is measured against distance from this event. If the team cannot agree on the sentence, that disagreement is your first finding, and probably your biggest.
2. Gather the evidence you already have
Funnel numbers per step if you have them, first-week support tickets, cancellation reasons, sales objections, and any session recordings. You are looking for convergence: a step that appears in the funnel drop, in the tickets and in the recordings is not a hypothesis any more. A user flow diagram with drop-off annotated on each step is the ideal artefact to walk into the audit with.
3. Walk the flow as a genuinely new user
Fresh account, fresh browser profile, no internal shortcuts, no seeded data, on a normal laptop. Screenshot every screen with a timestamp and write down what you thought at each one — including the moments of hesitation, which are the findings. Time the whole thing. The gap between how long the team believes this takes and how long it takes is routinely a factor of three.
4. Walk it again as an invited member
This is the step that gets skipped, and in most B2B products invited members are half or more of all new users. They arrive into somebody else's workspace, with fewer permissions, no setup context, and often into a product tour written for an admin creating something from scratch. Audit it separately — it is a different experience wearing the same UI.
5. Work through the checklist, layer by layer
Use the forty questions below. The value of a fixed checklist is that it forces you past the problems you already knew about and into the ones you had normalised.
6. Write findings, never solutions
One finding per line: what is happening, where, to whom, and the evidence. Resist writing the fix — half the value of an audit is that the fix gets chosen after the whole picture exists, not during.
7. Score and rank
Impact over effort, described in the next section. The ranking is the deliverable; an unranked list of thirty findings is indistinguishable from having no findings.
8. Split the list and start with the cheap half
Separate findings that require the product to change from findings that require the product to explain itself. The second group is usually larger, ships in days, and produces the evidence that makes the first group fundable.
The 40-Point Onboarding Audit Checklist
Eight questions per layer. Answer each one yes, no, or unknown — and treat "unknown" as a finding in its own right, because it means nobody is watching.
- Does the first screen after signup deliver what the landing page promised?
- Is the primary use case a new user arrives with the one the product opens on?
- Are pricing and plan limits discoverable before a user hits one by surprise?
- Does the signup CTA describe the outcome, or just the action ("start free")?
- Do the words used in marketing match the words used in the interface?
- Is there a demo or preview for people not ready to sign up?
- Do different acquisition sources land on an experience that fits their intent?
- Is anything promised that the product only delivers on a higher plan?
- How many fields are required, and is every one needed now?
- Can a user reach a working product before email verification?
- Is social or SSO login offered where the audience expects it?
- What happens on an invalid or already-registered email?
- How long is the median time from landing on signup to seeing the product?
- Is the invited-member signup shorter than the admin one?
- Does an interrupted signup resume, or restart?
- Are error messages specific enough to be fixed without support?
- What does the account look like with zero data — is the empty state designed or accidental?
- Is there exactly one obvious next action, or several competing ones?
- Can a user get to a real result without importing anything?
- Is sample or demo data offered, and is it removable?
- Does the first session end with something the user could show a colleague?
- Does any tour or welcome screen run before there is anything to point at?
- Is progress preserved if the user leaves and returns tomorrow?
- What does the second session open on — the same empty screen, or where they stopped?
- What is the shortest possible route to the "onboarded" event, in clicks?
- Is that the route the product actually offers, or a route only insiders know?
- How many steps require someone else — an admin, an IT team, a data export?
- Are there steps that can be deferred without blocking the first result?
- Do different roles need different paths, and does the product provide them?
- What happens when a step fails — a bad file, an expired invite, a rejected connection?
- Is there a point where the user must leave the product and come back?
- How does a user know they have succeeded?
- Is there help at each step where users measurably hesitate?
- Is guidance triggered at the moment of need, or all at signup?
- Can a user re-open a tour or checklist after dismissing it?
- Is guidance targeted by segment, or identical for everyone?
- Do two pieces of guidance ever appear at the same time?
- Can you name the single step with the largest drop-off, with a number?
- Is time-to-first-value measured, and is it trending?
- Would you know within a week if onboarding broke after a release?
Scoring: Turning Findings Into a Ranked Backlog
Give each finding three numbers on a one-to-five scale — reach (how many users meet it), severity (what it costs them when they do), and effort (what the fix takes) — then rank on reach × severity ÷ effort. The arithmetic is unimportant; making the inputs explicit is the point, because it lets someone disagree with a specific number instead of with your conclusion.
Then split the ranked list in two. Product changes go to the roadmap with real estimates. Explanation gaps — a step people reach and abandon, a control nobody notices, a state nobody designed, a path that only makes sense to admins — go into the guidance layer and can be live within days.
The Ten Findings That Show Up in Almost Every Audit
| Finding | Why it happens | Which half of the list |
|---|---|---|
| The tour runs against an empty account | It was triggered on signup because that was the default | Explanation — retrigger it later |
| The empty state was never designed | Nobody on the team has seen a zero-data account in a year | Mixed — copy now, layout later |
| Signup asks for things needed much later | The form grew one field per stakeholder request | Product |
| No obvious single next action | Every team wanted their feature on the first screen | Explanation — a checklist gives it an order |
| One flow serving several roles | The invited-member path was never separately designed | Explanation — segment the guidance |
| Guidance arrives before the question exists | Everything fires on page load | Explanation — change the trigger |
| Failure paths are undesigned | Bad imports and expired invites are edge cases in a spec, not in reality | Mixed |
| Session two starts from nothing | Progress was never persisted | Explanation — a checklist that resumes |
| Help exists but is three clicks away | The knowledge base is good and nobody reaches it in time | Explanation — surface it contextually |
| No measurement at the step that leaks | Instrumentation followed features, not the funnel | Product — and do it first |
✅ Do
- Walk the flow yourself, in a fresh account, timed
- Audit the invited-member path separately
- Write findings with a step, a segment and a number
- Treat "we don't know" as a finding
- Rank before you present anything
- Ship the cheap half while the expensive half is estimated
- Re-measure the same funnel 30 days after fixing
❌ Don't
- Design solutions while you are still gathering evidence
- Audit using an internal account with seeded data
- Skip the layers before signup and after activation
- Present thirty unranked findings
- Rely on a competitor teardown as evidence about your users
- Run one with no capacity to act on it
- Let it expand into a redesign project
After the Audit: Proving the Fix Worked
Findings are only worth the ranking if somebody re-measures. Fix, wait thirty days, and compare the same funnel for the same segment — not overall activation, which moves for a dozen reasons at once.
| What you fixed | What should move | If it doesn't |
|---|---|---|
| A step with high abandonment | Completion of that specific step | The cause was upstream, not on the step |
| Guidance timing | Guide completion, and downstream action | Wrong audience, not wrong moment |
| A signup field removed | Signup completion, and no drop in lead quality | The field was not the friction |
| An empty state redesigned | First-object creation rate | Users cannot create the object at all yet |
| A member-specific path | Activation within the invited segment | Members were never the constraint |
Keep the audit document and annotate it. Six months later, the record of what you found, what you changed and what moved is worth more than the original findings — it is the only way a team learns which of its instincts about onboarding are reliable. If you are still assembling the measurement layer, the user onboarding metrics guide covers what to instrument, and time to value covers the headline number most audits end up recommending.
Fixing the Cheap Half Without a Release Cycle
The reason audits are worth running before redesigns is arithmetic: the explanation half of the list is usually the larger half, and it does not need engineering capacity. With Kompassify, most of those findings become work you can complete in an afternoon:
- The step people abandon gets a short product tour or a tooltip at that exact moment, built visually on your live screens.
- The control nobody notices gets a hotspot — passive, ignorable, and enough to make it discoverable.
- The session-two problem gets an onboarding checklist that remembers per-user progress and resumes where they stopped.
- The one-flow-for-every-role finding gets segment targeting, so invited members stop being taught how to create the workspace they were invited into.
- The undesigned dead ends get a contextual message explaining what happened and what to do, while the real fix is scheduled.
- The measurement gap gets closed by the built-in analytics, which report reach and completion per step so the next audit starts with numbers.
Kompassify is GDPR compliant and EU-hosted, free for under 100 monthly active users, with paid plans from $129/month. You can also try a live demo before installing anything.
Fix What Your Audit Found — This Week
Most onboarding audit findings are explanation gaps, not engineering work. Kompassify adds product tours, onboarding checklists, tooltips and hotspots to your existing product with no code — targeted to the segment that struggles, triggered at the moment that matters, and measured per step so you can prove the finding is closed. GDPR compliant, EU-hosted, and free for under 100 monthly active users.
Start for Free →Frequently Asked Questions
What is a user onboarding audit?
A user onboarding audit is a structured review of everything that happens between a user signing up and reaching their first real result, carried out against a fixed checklist and real behavioural data rather than opinion. It produces a ranked list of specific findings — each tied to a step, a segment and a number — instead of a general sense that onboarding could be better. Its purpose is diagnosis, not design: the deliverable is an evidence-backed answer to "where exactly are we losing people, and why", which is what makes the redesign that follows worth doing.
When should you run an onboarding audit?
Four moments justify one. When activation has been flat or declining for a couple of months. Before committing to an onboarding redesign, so the rebuild is aimed at something real. After a significant change to the product, the pricing or the audience, because onboarding built for the previous version quietly stops fitting. And when support keeps answering the same first-week questions, which is onboarding failing in a measurable, expensive way. Running one on a fixed annual schedule with no trigger tends to produce a document nobody acts on.
What should a user onboarding audit cover?
Five layers. The acquisition promise — what the user was told before signing up, and whether the product matches it. Signup and account creation — friction, required fields, verification, time to first screen. The first run — what an empty account looks like and whether the first meaningful action is obvious. The path to value — whether the shortest route to a real result is the one the product actually offers. And the guidance and measurement layer — whether help exists at the right moments, and whether anyone can tell which step is losing people. Audits that examine only the middle layer miss most of the cause.
How do you audit onboarding without a lot of data?
Walk the flow as a genuinely new user, in a fresh account, on a normal laptop, with the same information a real signup would have — and take a timestamped screenshot at every step. Do it once as an admin creating a workspace and once as an invited member joining one, because those two experiences are usually very different and only one of them is ever tested. Then add whatever qualitative evidence exists: support tickets from the first week, sales objections, and session recordings if you have them. That is enough to find the top handful of problems even with no funnel instrumentation at all.
How do you prioritise what an onboarding audit finds?
Score each finding on how many users it affects, how much it costs them when it happens, and how much work the fix is — then sort by impact over effort. The result usually splits cleanly. Findings that need product or engineering changes go into the roadmap with a real estimate. Findings that are really missing explanation — a step people reach and abandon, a control nobody notices, a state nobody designed — can be fixed with guidance in days. Doing the cheap half first is what makes the expensive half fundable.
What problems do onboarding audits find most often?
The same short list, in almost every audit: a tour that runs against an empty account, an undesigned empty state, a signup form asking for information the product does not need yet, a first session with no obvious next action, one generic flow serving several different roles, guidance that arrives before the user has a question, an unhandled failure path such as a bad import or an expired invitation, a second session that starts from nothing because progress was not remembered, help content that exists but is three clicks away, and no measurement at the step where people actually leave.
How long does an onboarding audit take?
A focused one takes about a week of part-time work. Roughly a day to gather evidence and walk the flows, two days to work through the checklist and write findings, a day to score and rank them, and a half-day to present. Stretching it further rarely improves the output, because the top findings are usually obvious by the second day and the remaining time goes into documenting things nobody will fix. If it is taking a month, it has quietly turned into a redesign project.
How do you fix audit findings without waiting for engineering?
Separate the findings that need the product to change from the ones that need the product to explain itself, because the second group is usually larger and much cheaper. With a no-code platform like Kompassify you can add a product tour on the step people abandon, a tooltip on the control nobody notices, a checklist that remembers progress across sessions, and a contextual message on the dead ends nobody designed — built visually on top of your live product, targeted by segment, and measured per step. Kompassify is GDPR compliant and EU-hosted, free for under 100 monthly active users, with paid plans from $129/month.