NewThe guide: 11 paywall examples
Daily revenue of an app, before and after firstapp

Daily revenue. Before, then after.

Before you start

Two ways to waste time.

  1. 01

    We test at random.

    A competitor ships a paywall, we copy it. A conversion drops, we change the price. A designer proposes a screen, we put it live. We optimize a solution before we've named the problem.

  2. 02

    We change everything at once.

    New paywall, new price, new onboarding, new listing. Revenue moves. We no longer know what moved it. The next test starts from zero.

The point isn't to ship more tests. The point is to learn faster what moves the app forward.

The move

An experiment is a question asked of the product.

With a measurable answer. An A/B test is part of it. It isn't the whole of it.

We can experiment on the store listing, the onboarding, when the paywall appears, the offer, the price, the message, what happens after payment, the notifications, the cancellation path.

  1. Observe
  2. Understand
  3. Write a hypothesis
  4. Test
  5. Measure
  6. Learn

Finding a variant that converts better is the start. Understanding why it converts better decides the next test. That sequence is what makes progress, not a one-off hit.

The loop

Seven steps. Then we start again.

The same sequence on every app. Each round removes a share of uncertainty. The winner becomes the base of the next round.

01

Read.

Before we test, we have to see what's happening.

We read in the tool already in place. Amplitude, PostHog, for the journey. RevenueCat, Adapty, for revenue.

A monetization funnel often looks like this. Each step has its event. Events alone aren't enough. We also cut by source, country, platform, campaign, cohort, subscription type, tenure.

  1. Install
  2. Onboarding started
  3. Onboarding finished
  4. Paywall seen
  5. Trial started
  6. Subscription
  7. Renewal

An overall conversion of 4% can hide two apps inside one. People from TikTok at 1.5%, organic at 7%. That isn't one problem. It's two.

We reread the tests already run. An idea that lost doesn't come back under another name. If events are missing, we put them in before the first test. A test on a leaky funnel produces a number we can't trust.

02

Name the problem.

A metric says where to look. It doesn't say why.

Only twenty percent of people see the paywall. The quick reaction: show it earlier. That's already a solution. We aren't there yet.

We cross the number with reviews, tickets, cancellation reasons, sessions, and what users of the apps next door say. We look for the job they want done, what made them try, what holds them back, the words they use. Those words later become the onboarding and paywall copy.

We look at the journeys of the apps that work in the category, to see the patterns. We don't copy their screen.

People leave onboarding at step 5. Step 5 asks for an account, before the app has shown what it's worth. The testable problem: the account comes too early.

03

Write the hypothesis.

We always write it the same way.

We think [this problem] keeps [these people] from [doing this action]. We change [one thing]. We expect [this metric] to rise.

We think asking for an account too early creates friction before the person has understood the app. We move the account to after the first moment of value. We expect the onboarding completion rate to rise.

The difference is total. We don't test “a new onboarding”. We test the idea that one specific friction blocks activation.

The hypothesis, the primary metric, the secondary metrics and the guardrails are written before we draw. Otherwise the result gets read afterwards, in the direction we hoped for.

04

Choose.

A team quickly has thirty or fifty ideas. It can't ship them all.

We rank them with a simple rule: impact × confidence / effort.

Impact: if the hypothesis is right, what it changes on revenue. Confidence: what already supports it, in your numbers and in what we've heard. Effort: the time to design, build, and ship.

It avoids three weeks on a test whose possible effect is thin, while another ships in two days.

The usual order: offer and paywall tests first, when the volume is there. The big onboarding bets next. One test per screen at a time. Two tests at once on the same people contaminate each other.

05

Build the test.

A test is defined before it is built.

The control is the current experience. The treatment is the new one. The audience is the people who qualify. The primary metric judges the hypothesis. The secondaries fill it in. The guardrails are what must not get worse: refunds, retention at seven days, cancellations.

For a paywall. Hypothesis: a clearer promise raises the move to trial. Primary metric: paywall seen, then trial. Secondaries: install to trial, trial to paid, revenue per install. Guardrails: refund, retention, cancellation.

We change one variable. “New paywall” with five different things is a redesign. We can do that, when we're looking for a jump. We don't call it a causality test.

The same people see the same variant every time they open the app. An assignment that changes every session makes the number unusable.

The size and the end date are set before launch. We cover at least a full week, because weekdays and the weekend don't bring the same people. Two weeks at minimum if the decision is about trial-to-paid, or revenue at thirty days. We stop on the planned date. Watching every day and cutting as soon as “it's significant” manufactures false winners.

Few views, low conversion: we test a big change. The offer, the structure, the moment. A button detail on a small volume takes months for noise.

06

Read the revenue.

A paywall test isn't judged on the paywall.

Variant B raises trial start by 25%. It looks excellent. If those people convert to paid less often, the result is bad for the app.

  1. Paywall seen
  2. Trial
  3. Trial to paid
  4. Revenue per install
  5. Value over time

Four readings, from the fastest to the most solid. The trade names, next to ours. Trial to paid: trial-to-paid. Revenue per user: ARPU. Value over time: LTV.

  1. 01
    The trial rate. Fast. An offer people won't pay for can inflate it.
  2. 02
    Trial-to-paid. It says whether the paywall promised too much.
  3. 03
    Retained revenue at thirty days, per install. Slow. This is the money.
  4. 04
    Retained revenue further out. The reading for apps that can wait.

For most apps: we iterate on the trial rate, and we only call the new baseline after retained revenue. If the trial winner loses on retained revenue, the variant promised too much.

We reread the winner by channel and by country. A paywall that wins overall can lose on people who came from ads, often the ones who weigh the most.

We set aside what isn't the test: a season, a change in ad spend, a store feature, a price change on the side.

A test result: the firstapp variant against the control, on LTV and MRR

Control against the firstapp variant, read in RevenueCat. LTV realized +17.6%. LTV per paying customer +31%. MRR follows, +10.5%.

07

Keep it, or leave it.

A test doesn't end with “B wins, +12%”. We want the why.

  • It wins.

    We name what produced the gain, we roll it out to everyone, it becomes the control. The next hypothesis starts from there.

  • It loses.

    A hypothesis is disproved. The control stays. Only the test's share of traffic saw the variant. The reason goes on the list.

  • It doesn't decide.

    The problem still isn't understood, or the volume wasn't enough. We don't rerun it to confirm, without a new reason.

A share of people stays on the old version, long enough to check that the stacked gains still hold, taken together.

The surfaces

Seven places. Each has its metric.

Every test has its guardrails, so a gain here doesn't manufacture a loss further on. Optimization doesn't stop at the first payment.

01

The arrival.

The listing is the first conversion. We test the icon, the order of the screenshots, the message, the proposition, the language, the product pages.

MetricFrom impression to visit, then to install.

02

Onboarding.

It turns an install into understanding, then into activation. For many subscription apps, the trial is decided on day one, often in the first session. We test the number of screens, the order, the quiz, the personalization, when the account is asked for, when the app becomes clear, when the paywall appears.

MetricOnboarding finished. Install to paywall seen. Install to trial.

03

When the paywall appears.

When and where we show it weighs as much as what it contains. End of onboarding, the start, a locked feature, a usage limit, after an action.

MetricShare of installs that see the paywall. Conversion by place.

04

The offer and the price.

Trial length, or no trial. Monthly, yearly, lifetime. The price. The price by country. An entry offer. A bundle. It's often the biggest lever, and the slowest, because a price goes through the stores. A price increase can lower conversion and raise revenue. We judge revenue and value over time, not the rate alone.

MetricARPU. Mix of plans. LTV.

LTV per customer, before and after the first price test

LTV per customer. The first price test is the turning point.

05

The screen.

How the offer is read before the copy even starts. One screen or several. The scroll or the fold. The hierarchy of the price and the button. The proof next to the decision. Payment in the app or on the web, when that's the subject.

MetricPaywall seen, then trial, then purchase.

06

After the purchase.

Many apps drop the person into the product the second they've paid. We draw what follows: confirmation, the trial calendar, the first action that makes the purchase concrete.

MetricTrial-to-paid. Refunds. First-day cancellations.

07

Retention.

The loop that brings people back. Notifications, the reminder of the value, the cancellation path, the offer to stay, the return of those who left. A person who cancels gives the next hypothesis, if we ask why.

MetricSave rate. Renewal. Churn.

The paywall

We don't start with the visual.

The offer first. The button detail, only where the views are many.

01

The offer.

Yearly alone, or monthly and yearly. Three days, seven days, fourteen, or no trial. A free trial, or a low first price. The price itself.

02

The promise.

The outcome, or the feature. One line, or three. A sentence that picks up the answer given in onboarding.

03

The proof.

The rating and the review count near the button. A quote. A logo, when it's true. A usage volume, when the number is yours.

04

The button.

“Start the trial”, “Continue”, “Try for seven days”. “Cancel anytime” under the button. The price after the trial, shown or not.

05

The layout.

A long screen, or a single fold. Several steps, or one. A moving visual, or a still one. A multi-step paywall often helps cold traffic, and can get in the way of someone who already knows the app.

Two paywalls tested side by side, offer, proof and button

Two paywalls from the same test. Several things change: it's a redesign, not an isolated cause.

The color, the radius, the gradient: only where the views are many. On a small app, that test doesn't pay for the time it takes. The open screens follow the same order.

Before launch

What we cut.

  1. Confirmation.

    We believe B will win, and every signal goes that way.

    The hypothesis and the threshold are written before.

  2. The competitor.

    We saw a screen somewhere else, we assume it works.

    We start from your numbers and your users.

  3. The multiple test.

    Five variables at once, read as a single cause.

    One variable, when we're looking for a cause. A redesign named as such, when we're looking for a jump.

  4. The easy metric.

    We optimize what rises fast.

    One primary metric. Guardrails tied to revenue, renewal, retention.

  5. Reading too early.

    We cut because the curve looks good.

    The date is set before.

Yours

What you keep.

When the engagement stops, the list, the briefs and the readings stay yours.

  • 01
    The list of tests.

    Ordered, with the hypothesis and the score. We always know what's first, and why.

  • 02
    A brief per test.

    What we change. What we don't change. The metric. The guardrails. The date we read it.

  • 03
    A reading at the end.

    The why, not only the percentage. Winners in the app. Losers written down, so the next team doesn't replay them.

The pace

Hypotheses. Execution. Measurement.

Good hypotheses, and three weeks to ship each test: we learn slowly. Fast execution, and tests at random: a lot of noise. Good hypotheses, fast execution, and leaky tracking: we don't know what worked.

The three hold together. A roadmap answers two questions. What we build. What we're going to learn.

Common questions

Where do you start?

By the funnel. The step that leaks the most, then why people drop off there. We don't write a hypothesis before we've read the numbers and understood the problem.

Do you need a lot of users?

Volume depends on the metric, the starting rate, and the lift we're trying to see. With few views, we test the offer and the structure. We leave button details alone.

How long does a test last?

At least a week, to cover weekdays and the weekend. Two weeks if we're judging trial-to-paid, or revenue at thirty days. The end date is written before launch.

Do you change only one thing?

When we want to understand a cause, yes. A redesign can change several things at once. We name it as such, and we read it with more caution.

Which metric decides?

Retained revenue: ARPU and LTV, not the trial rate alone. Trial-to-paid says whether the paywall promised too much. If the trial goes up and retained revenue goes down, the variant promised too much.

How do you know a variant won?

Not on the percentage alone. On a rate, Fisher's exact test says whether the gap can be chance. The decision is read in Bayesian terms: the probability that the variant is ahead, written before launch, read on the planned date, on retained revenue. Below the threshold, we don't call it a winner.

How is this different from Growth?

Growth is working on monetization with the team that built the app. This page is the method we apply, on Growth and on an app we built.

What do we keep at the end?

The list of tests, the brief for each, and the reading. Winners are in the app. Losers are written down, so we don't replay them. All of it stays yours.

If
is one of a kind,
write to us.

Newsletter

Once a week.

Last issue

We opened 10 apps to see how they sell a subscription.

+534 people read us each week