Steller · Essay Series · Issue 02
Product-Led Growth
We Stopped
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.

↓ The shift that changed our onboarding
01
The old model

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."
Dimension
PLG 1.0 — Friction reduction
PLG 2.0 — Work reduction
User role
Active creator — you build it
Strategic reviewer — you approve it
Primary goal
Time to Value (TTV)
Effort to Value (ETV)
Mechanism
Better UI, tooltips, tutorials
AI output, automated workflows
Success metric
Feature adoption rate
Output quality, first-order speed
Empty state
A problem — causes churn
Eliminated — system pre-fills it
02
The Sudan insight

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.

03
What we built

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.

Before — PLG 1.0
User does all the work.
1Read documentation to understand the auth model
2Figure out how wallets and balances work
3Browse catalog to find a valid, active SKU
4Construct a valid order payload manually
5Debug the 400 / 401 / 422 error they inevitably hit
6Poll for status — if they remember to
Average time to first working order: hours. Common outcome: churn before they get there.
High friction · High churn risk
After — PLG 2.0
System does the work. User just reviews.
1Confirm wallet — balance shown immediately, no setup needed
2Fetch catalog — ready-to-order SKUs pre-filtered, no browsing
3Create order — sample request pre-constructed, one execution
4Track lifecycle — 202 accepted, status polling shown live
Average time to first working order: under 60 seconds. Partner leaves with proof the system works.
Minimal effort · Immediate confidence
The 60-second path — four steps, four confirmations
01
Wallet confirmed
Balance visible. Partner knows their funds are real and accessible. No configuration required.
Auth ✓
02
Catalog loaded
Active SKUs pre-filtered and ready. Partner doesn't browse — they see what they can order right now.
Catalog ✓
03
First order placed
Pre-constructed request. One execution. 202 Accepted returned. The system works — proven, not promised.
Order accepted ✓
04
Status trackable
Lifecycle visible immediately. Partner understands async reality without reading a word of documentation.
Trackable ✓
<60s
Time to first value
4
Steps total
4
Confirmations returned
0
Docs required to start
04
The thinking

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.

01
Reduce cognitive load — no unnecessary branching
The flow has one path. No decisions about which SKU to try, which format to use, which endpoint to call. The system makes those decisions. The partner makes the business one: do I like what this returned?
One path. No forks. No confusion.
02
Validate the core system early — before anything else
Auth, catalog, order lifecycle — these are the three things that must work for Steller to be worth integrating. We prove all three in the first 60 seconds. Not in a sandbox. In the real system.
Real proof. Real system. Real confidence.
03
Embrace async reality — track, don't wait
Gift card orders are async. The 202 is the value signal, not the PIN. We teach this without a single line of documentation — by making the lifecycle immediately visible after the first order.
202 is the signal. Teach it by showing it.
04
Great onboarding = fast diagnosis, not just happy paths
The three most common failure points — invalid API key, no active SKUs, unfunded wallet — are surfaced immediately with clear, actionable messages. Bad onboarding hides failure. Good onboarding makes it impossible to miss.
Surface failures fast. Remove ambiguity.
05
Design for the reviewer, not the builder
The partner's only active decision in the 60-second flow is: does this work? Yes or no. We have done everything before that question arrives. Their cognitive energy goes to business judgment, not technical setup.
Builder → Reviewer. The shift is the product.
06
Observable progress in seconds — not minutes
Every step returns immediate, visible feedback. Not a loading spinner. Not a "we'll email you." A real response, in the product, right now. Confidence is built through observable progress, not promises.
Feedback loops must be immediate.
05
What breaks

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:

Failure mode
PLG 1.0 experience
PLG 2.0 experience
Invalid API key
401 error. Partner reads docs, checks format, re-generates, retries. 20–40 minutes.
Step 1 fails immediately with a clear message: "Check your API key in the dashboard." Fixed in seconds.
No active SKUs
Empty catalog response. Partner doesn't know if it's their account, the region, or a bug.
Step 2 shows: "No active products in your catalog — contact your account manager." Clear owner, clear action.
Wallet not funded
Order rejection. Partner confused why the order failed when the request was valid.
Step 1 shows balance: $0.00. Partner knows before they try. No rejection, no confusion.
"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."
06
What to measure

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.

TTV-Auth
Time from signup to confirmed authentication
TTV-Order
Time from auth to first 202 accepted order
TTV-Track
Time from first order to first visible status poll
TTV-Scale
Time from first order to first production volume

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.

07
The point

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.

Next in the series
Issue 01 · The Steller Story
Built From the Rubble
Start with the failure that forced the redesign.
Read the essay →