The user signed up at 8:47pm. By 8:51pm they were stuck on something the in-product flow didn't explain. By 8:53pm they closed the tab.
You'll never see that user again.
That's where PLG conversion is decided. Not at the paywall. Not in the upgrade email. In the first session, alone, inside the product. The user came in to find out if your product solves a problem they have. If onboarding gets them to value fast enough, they come back, build a habit, and convert. If it doesn't, they don't.
In PLG, onboarding isn't a learning experience. It's behavior design — forcing value realization fast enough that the user comes back tomorrow.
What Activation Actually Means
Activation isn't signup. Signup just means the user filled out a form. Activation isn't feature usage either — a user can click around inside the product without ever experiencing what it actually does for them.
Activation is the first meaningful value realization. The moment the user does the thing they came to do and sees the result.
The numbers tell you why this matters. Userpilot's 2024 benchmark report puts the average PLG activation rate at 34.6% — meaning roughly two out of three PLG signups never reach the moment of first value. Top PLG companies target 40–60%, with best-in-class above 70%. The gap between average and best-in-class is the difference between a funnel that compounds and one that leaks two-thirds of its inputs at the first stage.
The activation event has to be three things. Observable — a specific action the system can detect, not a feeling the user reports. Measurable — you can count how many users hit it and how long it took. Repeatable — the same event for every user, predictably linked to whether they come back.
One nuance most teams miss: there's a difference between time-to-value and time-to-meaningful-value. Ultra-fast value can feel shallow. The user hits something the product calls an activation event, sees a quick win that doesn't actually map to the work they came to do, and never returns. The activation event has to be the thing the user came to do — not a proxy for engagement that the company found easy to instrument.
The actual event varies by product. A chat tool: sending the first 2,000 messages within two weeks. A project management tool: creating a project and inviting a teammate. A CRM: logging the first deal. A design tool: shipping the first finished asset. Whatever it is, you don't get to guess it. You find it in cohort data: pull fifty users who retained past day thirty and fifty who churned, look at first-session behavior, and the action retained users took that churned users didn't is the activation event.
Most teams are surprised by what they find. The event is rarely what the team would have guessed. It's almost never "completed onboarding" or "viewed the dashboard." It's something specific about the user doing real work in the product and seeing the result.
Time-To-Value Compression (And The Friction Worth Keeping)
Once you know the activation event, the next question is how fast the user gets there.
The pattern across high-performing PLG products is consistent: the fastest path to value wins. Top PLG companies aim to deliver first value in under five to fifteen minutes. The user who has to spend ten minutes setting up before they can find out if the product solves their problem mostly doesn't make it. Every additional step before the activation event drops the percentage of users who reach it. Friction compounds.
Most teams take this as a mandate to remove all friction. That's the wrong instinct.
Useless friction kills activation. Meaningful friction creates commitment. The signup form that asks for a phone number for no reason is useless friction. The setup step that asks the user to import their own data — the actual data they want the product to work on — is meaningful friction. The user who imports real data has invested. They're going to come back and check what the product did with it. The user who landed in a sandbox with demo data didn't invest in anything.
The audit is friction-by-friction, not blanket. Every step gets one question: does this step earn the user's investment, or does it cost it? Drop the steps that cost it. Keep the steps that earn it.
Four tactics, in order of impact:
Remove empty states. The user lands on a blank dashboard with "No data yet" and a generic illustration. They don't know what to do. Empty states are layout decisions; they're activation killers. Every empty screen is a conversion risk. Replace them with templates, sample data, or pre-built starting points so the user lands inside something that already shows them what good looks like.
Pre-populate — but not too much. Demo projects and starter content are useful when the user can't realistically bring their own data in the first session. They become a problem when they replace the meaningful step that would have made the user invested. The line: pre-populate enough that the user sees what good looks like, then ask them to add the one thing that's theirs.
Use templates as the default first experience. A template is a working configuration the user adapts, not an empty state they fill. The user gets value from the template immediately and customizes once they've decided to stay. The PLG products that activate above 50% have templates as the default first experience, not as an afterthought.
Eliminate unnecessary setup, not all setup. Team invites, integrations, advanced configuration, permissions — all of it gets pushed past the activation moment. The user can come back for any of that once they've decided the product is worth coming back for. But the one piece of setup that maps directly to the activation event — the data the user came with, the workflow they're trying to recreate — stays. That's the friction that earns the visit.
The math is unforgiving. If your activation rate is below 30%, the path is too long. The fix isn't more emails. The fix is a shorter path with the right friction kept.
Behavioral Onboarding, Not Linear Flows
The old model is the product tour. The user signs up, sees a five-step walkthrough that explains every feature, dismisses it, and is now expected to use what they just glimpsed.
The tour was for the company. The user wanted help with their work.
The modern model is action-triggered guidance. The product watches what the user is doing and surfaces help at the moment of friction — not before, not after. The user is going to hit one specific moment of confusion in their first session. They don't need a tour of every feature. They need an answer to the one question they have, at the moment they have it.
This connects to a bigger reframe: the goal of onboarding isn't completion. It's momentum. A user who finishes a checklist and never opens the product again has completed onboarding. A user who hits the activation event and comes back the next day hasn't — but they're the user who matters. Design for the second session, not the first checklist.
Three patterns that work:
Show the feature only when the user needs it. Contextual tooltips, inline guidance, progressive disclosure. The advanced feature stays hidden until the user is doing something where it would help. When it surfaces, it's relevant.
Trigger nudges based on inactivity, not calendar. The user who connected a data source but hasn't created their first deliverable in 48 hours gets a different nudge than the user who's logged in three times but hasn't connected anything yet. "Day 3 email" is a relic; it has no idea what the user has actually done. Behavioral nudges fire on the exact pattern that predicts the user is about to bail.
Skip the welcome survey. Most onboarding flows open with "tell us about yourself" — role, company size, use case. The instinct is to personalize the experience. The reality: early personalization is friction the user hasn't earned a reason to push through. They came to find out if the product works, not to fill out a form. Default to a strong opinionated path that works for the largest segment. Personalize after activation, when the user has a reason to invest in the product knowing them.
This is what we run at MatrixFlows: an in-product assistant connected to structured product knowledge that answers the user's question at the friction point in plain language. The user at minute four who's about to close the tab gets the answer that keeps them in the product. The CS team is for users who got past activation and have strategic questions.
The Real Drop-Off: Activation → Second Use
Most PLG teams obsess over the wrong stage. The signup-to-activation drop is visible and easy to fix. The activation-to-second-use drop is invisible and harder to fix — and it's where most users actually go missing.
The user who hit activation but never came back didn't really activate. The activation event was too easy, too shallow, or too disconnected from the work they were trying to do. They saw something. They didn't see enough to come back. Across most products, more users are lost in this gap than in the entire signup-to-activation funnel.
The fix is designed return, not hoped-for return. Day-2 return rate is the leading indicator that activation actually meant something. If activated users aren't coming back, the activation event is the wrong event — not a signup or onboarding problem. Three things move the metric:
The first session ends with a reason to come back. The user finished something they care about and the product showed them what's next. Not a feature tour of what they could do. The actual unfinished work that's now waiting for them tomorrow.
Re-engagement fires within 24–48 hours, behaviorally. The user who created a project but didn't invite anyone gets a different message than the user who created and shared. Calendar-based emails treat every user the same and lose to behavior-based nudges by a wide margin.
Progress is shown in user language, at the user level. "Made your first report" beats "completed step 2 of 5." When milestones map to what the user came to do, their perception of progress matches what the system is measuring. They feel further along than a checklist would have made them feel.
Habit Formation → Conversion
Activation is the start, not the finish. The PLG conversion funnel runs in four stages, in order: Signup → Activate → Repeat → Convert.
Onboarding · Grow Scalably
The conversion happens
before the paywall.
In PLG, conversion isn't a pricing problem. It's a habit problem. The user converts because they activated, came back, and built dependency — in that order. Skip a stage and the funnel breaks.
The PLG conversion funnel
Signup → Activate → Repeat → Convert
Stage 01Signup
Frictionless entry
No credit card. The user gets in to find out if the product is for them.
Industry baseline
~9% free→paid
Stage 02Activate
First meaningful value, in session one
The user did the thing they came to do. Saw the result. Saw the wall they'll eventually hit.
Stage 03Repeat
Comes back the next day
Habit forms. Activation that doesn't translate into return wasn't really activation.
Leading signal
Day-2 return
Stage 04Convert
Hits the limit they saw at activation
The dependent user upgrades because going back is harder than paying.
Activated convert
3–5x non-activated
The drop most teams miss
Activation → Second Use
More users go missing here than in the entire signup-to-activation funnel. If they don't return on Day 2, they didn't really activate.
Two weeks in
98% inactive
Where the funnel breaks — four failure modes
×
Too many setup steps before first valueBreaks at Activate
×
Over-explaining instead of guiding actionBreaks at Activate
×
No clear next action after first sessionBreaks at Repeat
×
Welcome survey before activationBreaks at Activate
What to do this week
01
Find your real activation event from cohort data
50 retained vs 50 churned. The action that diverges is the event.
02
Audit your friction step by step
Each step: does it earn the user's investment, or cost it?
03
Pull day-2 return rate for activated users
Below 40%? The activation event is too easy. Redefine it.
The contrarian point
If users need to be convinced to pay,
they haven't experienced value yet.
34.6%
average PLG activation rate — two of three signups never reach value
Activation gets the user to first value. Repeated usage builds a habit. Habit creates dependency. Dependency converts to paid. Skip a stage and the funnel breaks.
The mistake most PLG companies make is treating conversion as a paywall problem. They optimize the upgrade page, A/B test pricing copy, run trial-end emails. None of it works if the user hasn't built dependency. If users need to be convinced to pay, they haven't experienced value yet.
The contrarian point worth sitting with: there's a way to optimize activation that actively kills monetization. Make everything in the free tier too easy and too complete, and the activated user has no reason to upgrade. They got value. They got it for free. They have no incentive to pay because the limit they'd be hitting doesn't exist. The activation that drives conversion is the activation that ends with a clear, visible boundary the paid tier solves — a project size limit, a collaboration cap, a feature gate the user can see across.
The mechanic that actually works:
Stage 1 — Signup. Frictionless. No credit card. No invite required. The user gets in and finds out if the product is for them. The average PLG product converts about 9% of free signups to paid — but that includes the users who never activated. The funnel only works if the next stage works.
Stage 2 — Activate. First meaningful value realization, in the first session. The user did the thing they came to do. They saw the result. They saw the wall they'll eventually hit. This is the gate everything else depends on.
Stage 3 — Repeat. The activated user comes back the next day, then the day after, then the week after. They start using the product as part of their actual work. Across half of all products, more than 98% of users are inactive two weeks after their first action — because activation didn't translate into a returning habit. The activated user who doesn't come back didn't really activate.
Stage 4 — Convert. The dependent user runs into the limit they saw at activation. They've been using the product for two weeks. They've already moved their work into it. Upgrading is easier than going back. The conversion happens because the cost of not upgrading is higher than the cost of paying.
The conversion levers fire after dependency is real. Limits on free usage. Upgrade prompts at the moment the user hits the wall. Collaboration features that require the paid tier. None of these convert a user who hasn't activated. All of them convert a user who has — PQL-style users typically convert at three to five times the rate of non-activated signups.
The numbers worth watching across the four stages: activation rate by signup cohort (target 40–60%), day-2 return rate (the leading retention signal), free-to-paid conversion of activated users specifically (should run 3–5x the rate of non-activated users).
Where Most PLG Onboarding Fails
Across the customer operations teams I've worked with, the same four failure modes show up. Each one breaks the Signup → Activate → Repeat → Convert funnel at a specific stage.
Too many steps before value. The user lands and gets asked to invite teammates, connect integrations, configure permissions, and set up a workspace before they can do anything. Each step is reasonable. The cumulative effect is that the user spends ten minutes setting up before they can find out if the product is worth setting up. Most don't make it.
Over-explaining instead of guiding. The product greets the user with a feature tour, an academy invite, a welcome video, a setup checklist, and a popup tutorial. The user came to do work, not to study the product. By the time they could have hit a first win, they're tired and they've stopped reading. If your onboarding requires explanation, your product isn't doing the job.
No clear next action. The user finishes one step and lands on a screen with no obvious thing to do next. The product expects them to figure it out. They don't. They close the tab. The single clearest fix in PLG: at every moment in the flow, the user should know exactly what to do next. One action. One click away.
Generic experience after activation, not before. The instinct to personalize is right — the timing is wrong. Default to a strong opinionated path before activation, then personalize the second session based on what the user actually did. Most teams reverse this and lose users to a welcome survey before they've earned the right to ask.
None of these are user failures. Each one is a moment the playbook asked the user to keep going on faith — and the user didn't have that much faith yet.
What to Do This Week
Three actions. Each takes under an hour. None require new software.
1. Find your real activation event from cohort data. Pull fifty users who retained past day thirty and fifty who churned. Look at their first-session behavior. The one or two actions retained users took that churned users didn't — that's the activation event for your product. Most teams are surprised by what they find.
2. Audit your friction step by step. Walk the path from signup to activation event. For each step, answer one question: does this step earn the user's investment, or does it cost it? Drop the steps that cost. Keep the steps that earn. The path that compresses to under five minutes for a top user is rarely the one with zero friction — it's the one with the right friction kept.
3. Pull the day-2 return rate for activated users. The percentage of users who hit activation and came back the next day. If it's below 40%, your activation event is too easy and isn't predicting retention. The fix isn't a re-engagement email. It's redefining the activation event so it's the thing the user came to do.
The user who signed up at 8:47pm doesn't know your CS team exists. They don't know your help center is well-organized. They know they're stuck right now, alone, in a product they're not yet sure they need. MatrixFlows is free to start. Activation either happens in the product, or it doesn't. Everything downstream depends on it.
.svg)
.svg)
.svg)
