The 47% Activation Jump
A few months ago, a post on r/UXDesign got 452 upvotes and started a heated debate. The claim seemed impossible: a B2B SaaS company removed their entire onboarding flow and saw user activation jump from 28% to 41% — a 47% improvement.
The UX community was split. Half called it cherry-picking. The other half shared similar stories from their own companies. But here's the uncomfortable truth:onboarding often hurts more than it helps.
Controversial take ahead: This article challenges the assumption that onboarding flows are always necessary. If you're religious about user onboarding, prepare to have your beliefs tested.
We've been conditioned to think that good UX means holding users' hands through every step. But what if the best onboarding is no onboarding at all?
What Actually Happened
The Reddit case study involved a project management SaaS with a typical 5-screen onboarding flow: welcome message, feature tour, account setup, team invitations, and goal setting. Standard stuff that any UX designer would approve.
But the numbers were brutal:
Before: Traditional Onboarding
- 28% activation rate (users who completed first meaningful task)
- 43% onboarding completion (many stopped mid-flow)
- Average time to value: 8.5 minutes
- Support tickets: 127/week mostly about getting started
The team hypothesized that their onboarding was too long, so they tried shortening it. No improvement. They tried personalizing it. Still nothing. Then someone suggested the nuclear option: "What if we just... removed it entirely?"
They A/B tested 25% of new users with zero onboarding. Just a clean dashboard with smart defaults and clear next steps. The results shocked everyone:
After: No Onboarding
- 41% activation rate (+47% improvement)
- 100% "onboarding" completion (since there wasn't one)
- Average time to value: 3.2 minutes (62% faster)
- Support tickets: 89/week (30% reduction)
The no-onboarding group also had higher 7-day retention (67% vs 52%) and were more likely to invite team members (34% vs 28%). Six months later, they rolled out the change to all users.
"We realized our onboarding was teaching people about features they didn't need yet, instead of helping them solve their immediate problem."
Why Onboarding Often Fails
This isn't an isolated case. Companies like Duolingo, Slack, and even Facebook have found success by reducing their onboarding flows. Here's why traditional onboarding often backfires:
Friction Paradox
Adding steps to "help" users often creates barriers instead
Example: Duolingo found that reducing onboarding from 5 screens to 1 increased completion by 20%
Impact: Every additional step loses 10-20% of users
Premature Teaching
Explaining features before users understand their own needs
Example: Slack showing team management before users have sent their first message
Impact: Information doesn't stick without context
Information Overload
Cramming too much into the first experience
Example: Photoshop's overwhelming initial tour vs. Figma's minimal introduction
Impact: Analysis paralysis and immediate abandonment
Generic One-Size-Fits-All
Same flow for all users regardless of experience level
Example: GitHub showing beginners the same flow as experienced developers
Impact: Wastes time for experts, confuses beginners
The Friction Paradox
Here's the counterintuitive part: adding "helpful" onboarding steps often creates more friction, not less. Every additional screen is a chance for users to:
- Get distracted and leave
- Question if the product is worth the effort
- Feel overwhelmed by information they don't need yet
- Make mistakes that discourage them
Duolingo discovered this when they reduced their language selection onboarding from 5 screens to 1. They lost detailed preference data but gained 20% more active learners. The tradeoff was worth it.
The Premature Teaching Problem
Traditional onboarding tries to teach users about features before they understand their own needs. It's like explaining advanced chess strategies to someone who hasn't learned how the pieces move.
Slack learned this lesson the hard way. Their original onboarding explained team management, channel organization, and notification settings before users had sent their first message. Most users forgot everything by the time those features became relevant.
Learning Retention Research
Educational research shows that information retention is highest when learning is tied to immediate application. Teaching someone about features they won't use for weeks results in less than 10% retention of that information.
Information Overload
The average onboarding flow tries to communicate months worth of product knowledge in the first few minutes. This creates analysis paralysis and decision fatigue before users even start.
Compare Photoshop's overwhelming initial tour (showing dozens of tools) with Figma's minimal introduction (just the basic shape and text tools). New Figma users are creating designs within minutes, while Photoshop users often spend their first session just trying to figure out where things are.
When Onboarding Actually Works
Before you delete your entire onboarding flow, understand that removing onboarding isn't universally better. There are specific situations where structured onboarding is not just helpful — it's essential:
When Onboarding IS Necessary
- Safety-critical applications: Banking, healthcare, industrial controls
- Complex B2B tools: CRM systems, enterprise software with steep learning curves
- Highly regulated industries: When compliance requires user education
- Multi-user workflows: When individual actions affect team functionality
- Data migration required: When users must import existing data to see value
For example, a banking app absolutely needs to onboard users about security features. A medical device interface requires safety training. But even in these cases, effective onboarding focuses on essentials and defers everything else.
The key question: Is this information essential for safe, successful first use, or are we just being thorough?
Case Study: Revolut Banking
Revolut balances security onboarding with minimal friction. They require identity verification and security setup (essential) but defer features like budgeting tools, investment options, and crypto trading (nice-to-have). Users can start making payments within 3 minutes while learning advanced features over time.
The 4 Better Alternatives
Removing onboarding doesn't mean abandoning users. Instead of front-loading information, these approaches deliver help when and where it's actually needed:
1. Progressive Disclosure
Reveal features gradually as users need them
When to use: Complex tools with many features
Example: Notion shows basic blocks first, advanced formatting later
Implementation Steps:
- Start with core functionality only
- Introduce features based on user behavior
- Use contextual tooltips for discovery
- Track feature adoption to optimize timing
2. Contextual Help
Help appears exactly when and where it's needed
When to use: When users need guidance during specific tasks
Example: Gmail's compose window tips vs. upfront email tutorial
Implementation Steps:
- Trigger help based on user actions
- Place help near relevant UI elements
- Make it dismissible and non-intrusive
- Track effectiveness by completion rates
3. Learn-by-Doing
Let users accomplish real goals while learning
When to use: When the product value is best experienced firsthand
Example: Canva lets you create actual designs vs. showing feature tours
Implementation Steps:
- Provide real, valuable tasks
- Guide without interrupting flow
- Celebrate real achievements
- Make mistakes recoverable
4. Just-in-Time Guidance
Help arrives precisely when users attempt new actions
When to use: For features that aren't immediately discoverable
Example: Figma's component tips when you first try to create components
Implementation Steps:
- Detect when users need specific help
- Provide minimal, actionable guidance
- Don't repeat for returning users
- Focus on the current task only
💡 Pro Tip: Combine Approaches
The most successful products combine multiple approaches. GitHub uses progressive disclosure for advanced features, contextual help for complex workflows, learn-by-doing for repository creation, and just-in-time guidance for collaboration features.
How to Audit Your Onboarding
Not sure if your onboarding is helping or hurting? Here's a framework to evaluate your current flow and identify opportunities for improvement:
The Onboarding Audit Checklist
📊 Quantitative Signals
Red Flags:
- • Onboarding completion < 60%
- • High drop-off on specific steps
- • Long time to first value (> 5 min)
- • Low activation despite onboarding completion
Green Flags:
- • High completion rate (> 80%)
- • Quick progression through steps
- • Strong correlation with retention
- • Users reference onboarding content later
🗣️ Qualitative Signals
Warning Signs:
- • "Too many steps to get started"
- • "I forgot everything from the tour"
- • "Can I skip this and just use it?"
- • Support tickets about basic functionality
Positive Signs:
- • "This helped me get started quickly"
- • "I understood what to do first"
- • "The setup process was smooth"
- • Few basic getting-started questions
🧪 Test Questions
- • Can users accomplish their primary goal without the onboarding?
- • Do users who skip onboarding perform worse than those who complete it?
- • Is each onboarding step essential for safe/successful first use?
- • Can this information be delivered contextually instead?
- • Are we teaching features users won't need for weeks?
The A/B Test Protocol
Ready to test removing or reducing your onboarding? Here's a safe approach:
Testing Strategy
- 1. Start small: Test with 10-25% of new users initially
- 2. Define success metrics: Focus on activation and task completion, not just onboarding completion
- 3. Monitor closely: Watch for increased support tickets or user confusion
- 4. Test variations: Try shortened onboarding before removing it entirely
- 5. Segment users: Different user types may need different approaches
Onboard vs. Don't Onboard Framework
Use this decision tree to determine the right approach for your specific product and user base:
The Decision Framework
⛔ Full Onboarding Required
Choose comprehensive onboarding if ANY of these apply:
- • Safety-critical functionality (medical, financial, industrial)
- • Legal compliance requires user education
- • Complex setup essential for basic functionality
- • High-stakes decisions with irreversible consequences
⚠️ Minimal Onboarding
Choose shortened onboarding if MOST of these apply:
- • B2B tool with moderate complexity
- • Multi-user workflows requiring coordination
- • Data import necessary for value demonstration
- • Account setup affects functionality significantly
✅ No Traditional Onboarding
Consider removing onboarding if MOST of these apply:
- • Core functionality is intuitive
- • Value is immediately demonstrable
- • Users can achieve goals without setup
- • Consumer product with familiar patterns
- • Mistakes are easily recoverable
Mixed Approach Examples
Notion: No upfront onboarding, but progressive disclosure as users create content
Stripe: Minimal setup for basic payments, comprehensive docs for complex implementations
Canva: Jump straight into design creation, contextual tips for advanced features
Implementation Strategy
Ready to reduce or eliminate your onboarding? Here's a step-by-step approach that minimizes risk while maximizing learning:
Phase 1: Assessment (Week 1-2)
- Audit current onboarding using the framework above
- Analyze user behavior and identify drop-off points
- Interview users who completed vs. abandoned onboarding
- Map essential vs. nice-to-have information
Phase 2: Minimum Viable Onboarding (Week 3-4)
- Create stripped-down version with only essential elements
- Replace tours with contextual help systems
- Implement smart defaults to reduce setup burden
- Design clear empty states that guide next actions
Phase 3: A/B Testing (Week 5-8)
- Test reduced onboarding with 25% of new users
- Monitor activation, retention, and support ticket volume
- Gather qualitative feedback through surveys and interviews
- Iterate based on results and user feedback
Phase 4: Optimization & Rollout (Week 9-12)
- Refine the winning approach based on test results
- Gradually roll out to larger user segments
- Implement contextual help and progressive disclosure
- Monitor long-term metrics and continue iterating
⚠️ Risk Mitigation
Keep these safeguards in place while testing:
- • Monitor support ticket volume closely
- • Have a rollback plan ready
- • Test with lower-risk user segments first
- • Maintain comprehensive help documentation
- • Set clear success criteria before starting
The Bottom Line
The 47% activation improvement from removing onboarding wasn't magic — it was the result of questioning a fundamental assumption. Sometimes the best user experience is getting out of the user's way.
This doesn't mean all onboarding is bad. But it does mean we should be more thoughtful about when, how, and why we onboard users. The goal isn't to teach users about our product — it's to help them accomplish their goals as quickly as possible.
Key Takeaways
- Question everything: Traditional onboarding isn't always necessary
- Focus on value: Get users to their first success as quickly as possible
- Test before assuming: Your users might surprise you
- Context is king: Help when and where it's needed beats upfront tutorials
- Measure what matters: Activation and retention trump onboarding completion rates
The next time you're designing an onboarding flow, ask yourself: "What if we didn't have this at all?" The answer might surprise you — and your activation rates might thank you.
Common Questions About Removing Onboarding
Quick answers to help you get started
Stay in the Loop Design Updates
Get practical design tips and new updates. No spam, unsubscribe anytime.