Why B2B SaaS onboarding keeps failing, and what video games solved decades ago

The standard B2B SaaS playbook for product adoption is broken, and it's been broken for so long that the entire ecosystem has built businesses around the breakage.

A new user signs up. The product opens with every feature visible, every tab populated, every integration available. The team builds onboarding checklists, in-app tours, customer success calls, knowledge bases, and academies, all to bridge the gap between "user signed up" and "user understands the product." Then 60 to 80% of those users churn inside the first 30 days anyway.

The diagnosis is always the same: better onboarding. More guides. More videos. More CS touchpoints.

The diagnosis is wrong.

The problem isn't that users don't understand the product. The problem is that they see too much, too fast, with no path through it. The cognitive load of choosing where to start is what breaks them, and no amount of onboarding content fixes a product surface that's overwhelming by design.

There's a model that solved this problem fifty years ago. It's called video game design.

The Mario Kart principle, applied to B2B SaaS onboarding

Open Mario Kart for the first time. You get three cups. Three or four characters. A handful of karts. No 200cc. No mirror mode. No Rainbow Road.

You play. You unlock. You get better. The game gets harder as you do. By the time you're racing in 200cc mirror mode with the entire roster, you're a different player than the one who started.

That isn't a gimmick. It's how learning works. You start with constraints, master them, then the constraints lift. Each new feature lands on a foundation strong enough to hold it. The product gets denser as the user gets better, not before.

Now compare that to a typical CRM onboarding. Day one, the user gets every object, every workflow, every report, every integration, every AI surface. The product offers no path. It hands the user a fully unlocked save file and expects them to play like a speedrunner.

This is why B2B SaaS onboarding fails. The product is built for the year-two user, then asked to teach itself to the day-one user. That's not an onboarding problem. It's a product surface problem.

Why product adoption stalls when everything is unlocked on day one

There's a measurable cost to shipping every feature at once. Three patterns show up consistently in B2B SaaS teams trying to improve product adoption:

1. Users default to the shallowest possible workflow. When everything is available, users find the one thing they can figure out alone, do only that, and treat the rest of the product as scenery. The 80% of features they never touch were the 80% that would have justified the price.

2. Teams blame onboarding when the issue is structural. Every retention quarter, someone proposes redesigning onboarding flows. A new welcome modal. A new tour. A new checklist. None of it moves the needle long-term, because the issue is upstream: the product is asking new users to make decisions only experienced users can make.

3. The ecosystem absorbs the gap. Implementation consultants, system integrators, "expert" certifications, partner directories. Entire markets exist because products didn't build a progression curve. Customers pay for consulting because the product won't guide them, and the product won't guide them because consulting is profitable for the ecosystem.

This is the actual state of B2B SaaS onboarding today. The friction isn't a bug, it's a feature for everyone except the user.

What a malleable product looks like

The case for product adoption that works the way games work: the day-one UI and the year-two UI should not be the same product.

Not in a "we have advanced mode in settings" way. In a structural way. Features unlock as users demonstrate they're ready to handle them. The complexity ladder is built into the product itself, not bolted on as documentation.

This was hard to do in the pre-AI era. Personalizing the product surface per user was expensive engineering, so vendors shipped one product to everyone and let onboarding teams try to catch the fall. That constraint is gone. The infrastructure to render a per-user product surface, gated by behavior and context, is now standard.

A malleable B2B product would do four things differently:

• Day one ships the minimum viable surface. A CRM would ship records and pipelines, not workflows, reports, integrations, or AI agents. The advanced surfaces stay locked until the user is ready.

• Features unlock through use, not through pricing tiers. The trigger for unlocking the workflows engine is "the user has built a clean data model and used the pipeline for two weeks," not "the user upgraded to Business plan." Pricing is a separate axis from progression.

• The UI tells you what's locked and why. Same way a video game tells you "complete the Mushroom Cup to unlock the Flower Cup." Not hidden, not removed. Earned and visible.

• Power users opt out. There's always a "show me everything" mode for the consultants, the ops teams, and the early users who already know the product. The default isn't the ceiling.

In this model, the user is never given the full product. The full product reveals itself as they earn it. Onboarding stops being a separate workflow grafted onto the product. Onboarding is the product.

Why this matters more in the AI era

The argument for gamified product adoption gets stronger every quarter that AI capabilities expand. Two reasons:

The first is technical. Personalizing a product surface per user used to require building rules engines and feature flag systems by hand. Now the same infrastructure that lets a product render a custom email per prospect can render a custom UI per user. The cost of malleability collapsed.

The second is strategic. As AI agents become a primary interaction layer, the question of "why have a UI at all" becomes real. The answer, as Nicolas Sharp, CEO of Attio, put it recently at a panel in their London office: UI is mental cache. A well-designed interface you use every day is restful for the brain. You don't restart from zero each session. You don't burn cognitive load reconstructing context. The UI is the shortcut.

If UI is mental cache, the UI should evolve with the user. The day-one cache and the year-two cache are different caches, holding different things. A static UI forces the year-two user to look at a day-one product, or forces the day-one user to look at a year-two product. Both are friction.

A malleable UI solves both problems at the same time. And the AI layer makes it cheap.

Until the product evolves, expertise compresses the curve

The shift to malleable products is coming, but it isn't here yet. No B2B SaaS today ships a UI that genuinely grows with the user. The best products, the ones still young enough to have small surface areas, are closer. The mature ones are nowhere near it.

In the meantime, the fastest way to get good at any product is the same as the fastest way to get good at any game: play with someone who's been at it for ten years.

The path most teams take is the slow one. Sign up, poke around, find the surface they can navigate, ignore the rest, build half a system, hire a CS rep, watch the system decay over twelve months, then rebuild. Eighteen months from signup to operating a CRM the team actually trusts. Two years before the team is running the product at its real ceiling.

The fast path is to skip the discovery phase entirely. Bring in someone who already knows the product, has built it for fifty other teams, knows which features to turn on at month one and which to leave alone until month six, and compresses two years of trial-and-error into eight weeks of structured build.

This is what specialist implementation partners exist to do. Not to replace the team. To compress the curve.

How Novlini approaches this for Attio teams

Novlini is an Attio-only consultancy. We've been inside the product since it was a database with three objects. We've built CRMs for companies going from zero to Series B and from Series B to Series D. We've seen the data models that scale and the ones that quietly break at 50,000 records.

Our approach is structured around the progression curve the product hasn't shipped yet:

• Foundations first. We design the data model around how the team actually sells, not around the maximalist surface Attio offers. Objects, attributes, relationships, lists, the minimum the team needs to operate on day one.

• Layer in surfaces as the team is ready. Workflows, integrations, call intelligence, AI surfaces, MCP. Each layer added when the team can absorb it, not all at once.

• Train the team to operate the system. The teams that want to go all the way become operators themselves, and we step back. The teams that want to focus on selling keep us on retainer to evolve the system as the company grows.

In both cases, the team starts at a level it would have taken them eighteen months to reach alone. The compression is the value.

The other reason teams keep us around: at a certain point, expertise should be externalized. You don't want your head of revenue spending Thursday nights tuning Attio workflows. You want them selling. Specialist tools get handled by specialists. Operators do the operating.

If your team is on Attio and the product feels bigger than your bandwidth to learn it, we can help. Either by handing you the cheat codes and stepping back, or by staying in the loop as your CRM grows with the company.

The next era of product adoption

Most B2B SaaS still ships with every cheat code enabled. Every feature, day one, no progression. Then the vendor wonders why adoption stalls, why retention sags, why CS teams burn out trying to teach a product the product won't teach itself.

The AI era is going to change this. Not by replacing UI with chat boxes, but by enabling UIs that grow with the user. Products that genuinely start simple and end complex, the way every good game does. Onboarding that is the product, not a separate workflow grafted onto it.

When that future arrives, the role of specialist partners doesn't disappear. It gets sharper. The product handles the progression. The specialists handle the ceiling.

Until then, the fastest path to product mastery is still the oldest one: find someone who's already great, and play with them.