How exactly is this 37.5% activation rate figure defined and calculated?
Activation rate is defined as "what percentage of newly registered users reach a milestone that represents genuinely experiencing the product's core value," calculated by dividing the number of users who hit that milestone by total new signups, then multiplying by 100. This milestone varies by product — a project management tool might use "created their first project," a design tool might use "completed their first shareable piece of work" — the key is that the milestone has to correspond to the moment a user actually feels the product's value, not a looser definition like "logged in once."
The 37.5% figure comes from Userpilot's 2025 benchmark survey of 62 B2B SaaS companies, representing the average across those companies, with the median landing around 37% — roughly consistent with independent surveys from other sources (around 36%), suggesting this isn't an isolated single-source number but a broadly cross-validated phenomenon.
Why does the "touch it first, understand later" ordering produce a higher activation rate than "explain first, touch it later"?
The core reason relates to how people actually learn new tools: abstract explanatory text ("this feature helps you organize your project quickly") is hard to genuinely absorb when the user has no real context to map it against yet — reading it usually leaves only a vague impression. But if a user personally experiences, mid-action, "oh, dragging this actually organizes the project," that understanding is concrete and attached to a real action, and retains far better.
Another reason is psychological: right after signing up, users carry an exploratory mindset of "I want to find out if this can actually help me," not a learning mindset of "I want to sit through a lesson about this tool first." Feature-tour tooltips assume users are willing to spend time passively absorbing information, but that assumption itself is at odds with what the user actually wants to do right now — get an answer to "is this tool useful" as fast as possible, rather than passively sitting through an introduction. Letting users act immediately directly answers their most urgent question.
"Show value first, collect data later" sounds reasonable, but what if the product genuinely needs some basic information to function — say, needing to know a user's industry to show relevant examples?
In this case, the key isn't skipping data collection entirely — it's compressing "collecting data" and "creating value" into the same action as much as possible, rather than splitting them into two sequential steps. For example, instead of first asking "what's your industry" and then showing a matching example, you could let users pick directly from a few concrete industry-example icons to get started — that selection action itself both collects the data and immediately puts the user into a working context. Both things happen together in the same interaction, rather than requiring a completed questionnaire before showing anything at all.
If a product genuinely needs some basic setup that can't be skipped (mandatory account security information, for instance), it's worth considering whether that setup can be pushed until after the user has already seen a first result, rather than placed right at the very start. After a user has experienced value, their tolerance for "spending a bit more time on setup" is typically noticeably higher, because the data collection at that point has a clear rationale behind it — "this is so the product can better fit what I need" — rather than context-free data collection demanded right out of the gate.
If I'm not a professional designer and I'm just using an AI design tool to build an onboarding first screen for a small product, how does this advice actually translate into practice?
The most direct thing you can do is figure out clearly "what specific thing should remain on screen after the user completes their first action," and get that answer clear before you start generating the screen — rather than starting with "what should this first screen look like." For example, if your product is a note-taking tool, that specific thing might be "the user's first note"; if it's a design tool, it might be "the first shape the user dragged out." Once you're clear on what that concrete artifact actually is, explicitly require in the prompt that the AI-generated screen actually shows that artifact after the interaction, rather than just popping up a confirmation like "Great, on to the next step."
The second thing you can do is deliberately audit your current first screen and check whether it requires users to fill out an entire form or read through an entire Block of introductory text before seeing any real content. If it does, consider whether the non-essential parts can be pushed later, leaving only the truly essential, unavoidable minimum of information, so users can get into "hands-on" mode as quickly as possible.
Userpilot's 2025 benchmark survey of 62 B2B SaaS companies found an average activation rate of just 37.5% — meaning more than 60% of new users leave before ever actually experiencing a product's core value. This figure varies substantially by industry — as high as 54.8% for AI-related tools, as low as 5% for finance-related products — but the overall trend holds: most products lose people who might otherwise have stuck around, within the first few minutes after signup. This piece isn't about designing an entire onboarding flow — it's focused specifically on that very first screen: what users should see and do in their first 60 seconds, especially if you're using an AI design tool to quickly generate that screen.
For a decade, SaaS onboarding first screens ran on the same formula: a sequence of feature-tour tooltip bubbles pointing at capabilities the user hadn't asked about yet, on a fixed rhythm of "Next, Next, Done." The problem with this formula isn't poor execution — the formula itself has a structural flaw. Most users dismiss these tours within seconds, because the tour is explaining something they have no need for yet and no context to understand. The core assumption of the traditional approach is "help the user understand the product first, then let them touch it" — but that ordering itself is part of what causes so much early drop-off.
The best-performing products flip this almost entirely: get users to create a real artifact within the first 60 seconds, and let understanding happen naturally around that thing they've already made. Figma's onboarding is the most commonly cited example — new users don't watch an introductory video about the design tool first; they're dropped straight into a canvas, immediately able to drag, draw, and watch things appear on screen in real time. This ordering works because "having made something" is itself a form of learning — the user doesn't need to be taught how to use the tool first; the act of doing it teaches them.
Another pattern worth noting is pushing the timing of data collection later. The common older approach was to have users fill out a batch of setup questions first (what industry are you in, what's your team size, what problem are you trying to solve) before letting them see what the product actually looks like. Better-performing products flip this: let users experience a concrete result first, and only then collect the data needed for personalization as it's actually needed. The logic behind this reordering is that filling out data before a user has seen any value is itself a form of friction, and relatively few people are willing to push through that friction upfront. But if a user sees a concrete result first, they're already motivated to provide data when it's later requested, because they already understand "filling this out means the product can build something that better fits what I need."
If you're planning to use a tool like Claude Design to quickly generate an onboarding first screen, the easiest trap to fall into is misreading "getting hands-on" as "adding more interactive elements" — piling in more buttons, more clickable things, to make the screen look richer. But the core of "a real artifact in the first 60 seconds" isn't the number of interactive elements — it's whether, after the user acts, something concrete and genuinely their own actually appears on screen, rather than just switching to a different screen or popping up a confirmation message. When writing the generation prompt, it's worth explicitly requiring: "After the user's first interaction, the screen should retain a visible artifact that belongs to the user, not a transitional screen that just moves them to the next step."
If you're designing or redesigning a product's first screen, it's worth actually running through the flow yourself with a timer and seeing how long it takes, how many fields need filling, and how many blocks of explanatory text a user needs to read between arriving and "creating the first thing that's genuinely their own." If that time significantly exceeds a minute, or a user has to fill out an entire form before seeing anything at all, that usually signals the first screen has "explaining" placed before "experiencing," and it's worth considering swapping the order. The cost of this adjustment is usually low — often it's just reordering a few steps rather than a full redesign — but the potential improvement in activation rate, measured against that 37.5% industry average, is substantial.