Teaching. We Started Doing.
PLG used to mean reducing friction. We learned — from building software in Sudan, of all places — that the real unlock is removing the work entirely. Here is how we applied that to Steller.
Onboarding used to mean
teaching you how.
For years, product growth was a friction problem. If users were not activating, the assumption was always the same: the path to value was too long, too confusing, or too manual. So product teams built better tooltips. Cleaner checklists. Smarter empty states. Shorter setup flows.
This worked — when software was a static workbench. When the user was always the one who had to pick up the tools and build something. The job of PLG 1.0 was to make the workbench easier to use.
But software has changed. AI has changed what a product can do before the user touches anything. And the old friction-reduction playbook is now the wrong answer to the wrong question. The question was never "how fast can the user learn?" It was always "how fast can the user see value?"
"PLG 1.0 asked: how do we reduce friction? PLG 2.0 asks: how do we eliminate the work? These are not the same question."
A business lesson from
the hardest market in the world
Before Steller, before software, there was Sudan. Business development in a market defined by risk, limited information, and complex internal politics teaches you something that no product course ever will: sometimes the fastest way to win a contract is to do the customer's internal work for them.
You don't wait for the customer to understand your product. You understand their business. You solve the internal blocker they can't articulate. You train their team on the thing they didn't know they needed. You make yourself so useful inside their organisation that they can't say no — not because they have to, but because you already did the job.
This is PLG 2.0 in human form. Not reducing friction. Removing the requirement to act at all. The customer becomes a reviewer, not a builder. And the barrier to yes collapses from "do I understand this?" to "do I like what they made?"
"In Sudan, we learned to win contracts by doing the customer's internal work for them — overcoming their politics, training their teams, removing every reason to say no. We just didn't know we were inventing PLG 2.0."Muhanad Abdelrahim — Founder, Steller
When we built Steller, we brought that instinct with us. Our partners — B2B companies integrating a gift card API for the first time — face the same blockers. They don't fully understand the system. They have internal stakeholders to convince. They need to see it work before they can sell it internally. So we stopped asking them to learn. We started doing the first part of the work for them.
From empty dashboard
to first order in 60 seconds
The old Steller onboarding was PLG 1.0 by default. A partner signed up, got access to the dashboard, and faced documentation. They had to read the API reference, understand the wallet system, find a working SKU, construct a valid request, and run it. For a developer this took hours. For a business user it took days — or they churned.
We redesigned the getting-started experience around a single principle: the fastest way to build confidence is to run the smallest possible flow that proves value, then expand.
We called it the 60-Second Path. Not documentation. Not dashboards. Not promises. Execution, feedback, and confidence — in four deterministic steps.
Why this works —
the product logic behind it
The 60-second path is not an onboarding trick. It is a product philosophy. Every decision in the flow reflects a deliberate choice about where cognitive load belongs — and where it doesn't.
Most failures aren't technical.
They're setup gaps.
When we analyzed integration failures in the old flow, almost none of them were API bugs. The system was working. The partner had made an error that no amount of documentation would have prevented — because they hadn't read it, or hadn't retained it, or had simply guessed wrong.
The three failure modes we see most often — and how PLG 2.0 surfaces them immediately instead of letting partners debug for hours:
"The insight is simple but it changes everything: great onboarding is fast diagnosis, not just happy paths. Surface failures immediately. Remove ambiguity. Make the right move obvious."
Stop measuring adoption.
Measure time to first real moment.
PLG 1.0 measured feature adoption. Did the user discover the catalog? Did they click the order button? Did they complete the setup checklist? These metrics feel useful but they measure the wrong thing. A user who completes a checklist and never places an order has not experienced value.
PLG 2.0 measures moments. The first moment the system proves it works. The first moment a partner trusts the integration enough to continue. These are different from feature metrics — they are confidence metrics. And confidence is what converts integration partners into paying customers.
The first three happen in the getting-started flow. The fourth is the conversion event — when a partner moves from testing to production. The entire onboarding strategy exists to compress the distance between signup and that fourth metric.
Because what gets measured gets improved. And what gets improved — when you're measuring the right thing — is the speed at which a partner becomes a customer.
PLG 2.0 is not a feature.
It's a philosophy.
The shift from friction reduction to work reduction sounds incremental. It isn't. It changes who the product is designed for, what success looks like, what you measure, and what you build next.
In PLG 1.0, the product is a tool. You optimize the tool for discoverability. In PLG 2.0, the product is a service. You optimize the service for output quality. The user is no longer learning how to use the tool. They are evaluating what the service produced.
The barrier to entry is no longer "how do I use this?" It is "do I like what this made for me?" That is a fundamentally easier question to answer — which means it is a fundamentally faster path from signup to confident customer.
We learned this in Sudan. We applied it to API onboarding. The principle holds everywhere: the fastest way to build trust is to do the first part of the work before they have to ask.