“It’s simple, but it ain’t easy.”

"It's simple, but it ain't easy."

After about 100 very focused left leg roundhouse kicks, my coach told me that I still wasn't getting the technique right. As much as I focused on what I knew I was supposed to do, my foot wouldn't pivot all the way and my balance was off. He told me two things (on repeat) that I think apply to almost everything in life—including product leadership.

New user onboarding isn't a hard concept to grok. You want to give users the most direct path to understand the value your product provides. Teams get hung up on what the most direct path is and sometimes even on what it means to understand the value of the product… putting it in the simple but not easy bucket.

Why I started doing blind runs

About a year ago, I started doing something that felt almost embarrassingly simple: I'd record myself trying new software for the first time and just... talk through what was happening. No script, no editing magic, just me fumbling through onboarding flows and sharing my honest reactions. At first I did this for partners I was working with through Nova Registry. After getting some positive feedback and realizing how much I enjoyed the process, I decided to start doing it for some of the newer or more notable SaaS products I had been meaning to try out.

I wasn't trying to create a "series" or anything formal. I was just deeply interested in how different teams approached the process—especially those who were innovating with new products or experiences like Opus Clips. Part of this was because I have been working on onboarding and signup flows for the better part of a decade and I just like to get new ideas, and part of this was frustration in how hard it was to discover the potential of some really great products—hoping they might find my content and make some updates.

Over the course of several months, I broke down nine different products: Sidekick (shut down), SparkToro, Arc, Coda, Linear, Perplexity, Reclaim, Typeform, and Opus Clip. Looking back, I think this might be some of the most valuable content I've created—not because it's polished or comprehensive, but because it captures something real about what actually happens when users encounter your product for the first time.

To toot my own horn a bit, I picked a pretty good lineup:

• Sidekick shut down - presumably too complex and too expensive as you can see it’s my longest video and definitely the most confusing experience.

• Arc by The Browser Company was acquired by Atlassian - mostly for their next gen browser Dia

• Reclaim was acquired by Dropbox

• Coda was acquired by Grammarly (along with Superhuman)

• Opus, Linear, and Perplexity have all seen significant growth

The Four Things That Keep Coming Up

1. The Best Onboarding Gets Out of Your Way

This one surprised me because it feels counter-intuitive. We're told that onboarding is about "teaching users how to use the product," but that's not actually what the best experiences do at all.

SparkToro nailed this. Their product tour was effective because it got out of my way and let me use the product, then waited till I was done before telling me what the next thing I was going to see was. Most product tours give you either a massive checklist or they take over your entire screen and try to show you everything at once. No one is going to remember any of that.

Perplexity AI takes this even further. You don't even need to sign up to start using it. You just show up and start asking questions. They trust that you'll find it useful enough to create an account once you want to save your work.

Compare that to Sidekick, where I felt stopped and interrupted by the onboarding wizard constantly. It kept redirecting me to other things instead of letting me experience the browser the way I wanted to right then. My conclusion in that video was pretty blunt: pretty rough.

The lesson: Your goal isn't to demonstrate value, it's to create an environment where users can discover it themselves. Every barrier you put up—even the "helpful" ones—creates friction that kills excitement.

Game design connection: This mirrors the concept of player agency—giving players meaningful choices rather than forcing them down a single path. Games that respect player autonomy (like Breath of the Wild) create more engagement than those that lock players into rigid tutorials. Your onboarding should feel like an open-world game, not an on-rails shooter.

2. Teach Through Action, Not Demonstration

Getting out of the way is step one. But you can't just throw users into an empty room and hope they figure it out.

Linear got this right. One thing I really appreciated in the onboarding experience was how they create the build-your-own-adventure vibe while also leveraging progressive disclosure. For example, instead of showing you a diagram of keyboard shortcuts, they actually make you use them to navigate the initial setup. You learn by doing, not by watching, and the goal isn't that you memorize all of them on day 1—it's that you know they exist so you can start using them from day 1.

Typeform did something similar by having you create an actual form during onboarding using AI. The tour then appeared on top of your generated content, showing you how to customize what you just made. This gave immediate, tangible value while teaching the interface.

This is the opposite of what Sidekick did. They mentioned features I hadn't seen yet and used terminology I wasn't familiar with. You're hearing about things you can't use yet while basic patterns you expect to see just aren't there. There were a lot of things to learn but I never felt like I was getting a chance to really learn them.

Coda had a similar problem. A wizard popup appeared at the same time as placeholder content, making it hard to maintain focus. I still use Coda to this day but when I try to leverage advanced features I am usually disappointed in what they can or can't do.

The lesson: Learning sticks when it solves a problem the user is facing right now. The most powerful lessons come from a user's own successful actions, not from demonstration.

Progressive disclosure connection: This UX pattern reveals information gradually as users need it, preventing cognitive overload. Instead of front-loading everything in a tutorial, introduce concepts at the moment they become relevant. Learn more: How games teach without tutorials.

3. You're in a Race to the First "Aha!" Moment

Every product has that moment where the user goes "oh, I get it now" or "oh, this is actually useful." The faster you can get them there, the better your chances of keeping them.

Linear felt really obvious to me because there's a lot of contrast between the product and the products they compete against like Jira. The well-defined structure to the issues, fast ways to add information or update ticket data, and simple and configurable projects and views made it feel like I had been wearing a weighted vest lined with spikes and finally had the chance to take it off. Just look at the attention to detail they put in their hover states.

If you want to know how I really feel about Jira… there's this.

Opus Clip delivered this differently. The core product is brilliant—it takes long-form video and automatically edits it into shareable clips. Even though the interface was rough with disconnected elements, the AI's ability to identify relevant keywords from a prompt and generate quality clips made the value undeniable. The product itself was the "aha" moment.

Arc Browser was interesting because I eventually found some really powerful features, but I had to discover the command bar on my own by digging through docs. It would have been nice if they showed some of those magic moments a little bit sooner.

The lesson: Don't hide your best features behind a learning curve. If you have something genuinely useful, show it immediately. Bet on your user's excitement, not their patience.

Game design connection: Games call this the "hook"—the moment that gets players invested. Great games put their most compelling mechanic in the first few minutes. Portal starts with the portal gun. Mario starts with jumping. Your product should do the same—lead with your most compelling capability, not your most complex.

4. Design Decisions ARE Experience Decisions

Onboarding isn't just the guidance or education you give new users, it's every interaction they have in those first sessions before they are getting real use out of the product. This includes how and when you introduce different features, the way you connect the workflows between them, the navigation options you give to the user, and even the microcopy that helps them understand the product and validate their assumptions.

Arc showed this well with their color picker during initial setup—it was unconventional but fun. The playfulness matched their brand and set the tone for a different kind of browser experience. Every design choice communicated their philosophy. Every designer I’ve showed this too agreed that it was really interesting and felt fun but had terrible usability in terms of getting a design you want.

SparkToro's homepage was genius in this regard. It clearly stated who the product was for and what problem it solved. More importantly, they didn't just show data—they included guides on how to apply the data. This showed they understood the complete user journey, not just the data retrieval step.

Reclaim.ai had good intentions but stumbled on execution. The tutorial modal used a reddish-pink color scheme that mentally signaled an error rather than education. The working hours feature was a bit too complicated to try and tackle in that first session. Little decisions like that across the different feature areas made it easy to get lost on the way to solving the problem or getting to what that product does really well.

Sidekick kept tripping over this. On their app selection screen, I remember being confused about whether or not I had selected an app I wanted to connect. Generally speaking, active states are brighter, colored in, and more obvious and inactive states are faded out, neutral, and "sleepy" looking. Sidekick reversed this for the step to connect apps and it really took me a while to verify how it was supposed to work.

Opus Clip had a few navigation dead ends. After processing my video, the email link led to a page where the UI failed to load. I had to manually find my way back to the dashboard—a great way to confuse the hell out of people who just got excited about your product.

The lesson: Trust is built or broken in these micro-interactions. Every pixel, every word, every transition either reinforces that you understand your users or reveals that you don't.

Design systems connection: Just as design systems maintain visual consistency, your onboarding should maintain experiential consistency. If your product values speed, your onboarding should be fast. If you value simplicity, don't make setup complex. The experience should reflect and validate the value proposition. Learn more: Check out Atomic Design principles and how they apply to user experience patterns.

What To Do With These Insights

Looking at these patterns across nine products, here's what I'd focus on if I were auditing my own onboarding:

Map Your User's Mental Model First

Before designing any onboarding flow, understand what users expect to see based on their existing mental models. Perplexity works because search is a familiar pattern. Linear works because issue tracking is familiar, they just made it better. Sidekick struggled because they invented new patterns without bridging from familiar ones.

Action item: List the 3 closest product analogies to yours. What do users already know from those experiences? Design your onboarding to leverage that knowledge, not fight it.

Identify Your Single Most Impressive Moment

What's the one thing in your product that makes new users go "oh, that's different" or "oh, that's useful"? Not your most complex feature—your most resonant one.

Action item: Watch 5 user sessions of people using your product for the first time. Note the exact moment their body language or tone changes. That's your hook. Get users there in under 60 seconds.

Audit Your Micro-Copy and UI States

The words you use and visual states you show reveal whether you understand your users' perspective or are speaking from your internal team's context.

Action item: Screenshot every screen in your first-run experience. For each:

• Is the UI state obvious? (What's selected, what's active, what's next)

• Is the copy in user language or your internal terminology?

• Are instructions appearing where users need them or where it was convenient to put them?

• Do error messages help or just inform?

Test the "Walkaway" Threshold

How long can someone use your product before they get confused or stuck? That's your onboarding boundary—the point where you need to provide contextual help.

Action item: Time how long new users last before asking a question or looking confused. Place your contextual education just before that threshold, not scattered throughout the entire experience.

Build for Progressive Mastery

Your onboarding shouldn't try to teach everything—it should teach enough to be successful, then reveal depth as users need it. Think of it like game levels: teach one mechanic, let users master it, then layer on the next.

Action item: Map out your feature depth in three tiers:

• Tier 1: Core features needed for first success (teach immediately)

• Tier 2: Features that improve the core workflow (reveal contextually)

• Tier 3: Power user features (hide until they're ready)

The Real Takeaway

After watching myself stumble through nine different onboarding experiences, the pattern is clear: the best products don't try to teach everything upfront. They create an environment where discovery feels natural, actions feel meaningful, and value appears quickly.

It's simple—give users agency, teach through action, show your best stuff immediately, and sweat every micro-interaction.

But it's not easy. Because doing this well requires:

• Brutal honesty about what's actually essential vs what you think is important

• Discipline to cut "helpful" features that create friction

• Empathy to see your product through genuinely fresh eyes

• Patience to watch real users struggle with things that seem obvious to you

The teams that get this right understand something fundamental: onboarding isn't about showing users your product. It's about getting out of their way so they can discover what your product can do for them.

Watch the Full Season 1 Playlist

The complete Season 1 playlist includes all nine unscripted breakdowns with real-time reactions. Fair warning: they're unpolished, unscripted, and sometimes I get genuinely frustrated. But that's kind of the point.

Also check out this fantastic book all about onboarding from Ramli John

What's Next: Season 2

I'm starting another run and expanding into more AI native products, multi modal experiences, and even developer tools.

• Heygen

• Elevenlabs

• Github

• Render.com 

• Napkin.ai 

• Gemini App vs Google AI Studio

• Ollama and maybe 5ire

Taking requests: If you're building a product and want an unfiltered breakdown, let me know. If there are specific products you want to see analyzed, I'm listening.