Part three of the monetization playbook. Eight decisions, run in order for every new product — each one constrains the next. Every move here is an application of the arithmetic or the psychology; when a claim rests on either force, that’s where it’s derived. When you’re actually pricing a product, work from the runbook.

#Decision 1 — Position before you price

A price is one number, but willingness to pay is a distribution — some people would pay $5, some $500. One price pinned to the middle of a wide distribution loses both tails at once: the low end doesn’t buy (lost volume), the high end pays a fraction of what they would have (lost margin). The width of the distribution bakes in the loss; the only fix is multiple prices; multiple prices require knowing where the clusters are. That’s why segmentation comes first — it’s definitional, not procedural.

Segment by willingness to pay and the reason for it, never by demographics. “Agencies vs individuals” is a real segmentation only because it proxies a WTP difference — agencies bill your output to clients. The generative question: whose alternative to this product is expensive?

And positioning is pricing, mechanically: price is judged against a reference alternative, and your positioning chooses which alternative that is. “A better todo app” gets compared to free todo apps — ceiling $5. “The system that makes sure client work never slips” gets compared to the cost of a dropped client — ceiling in the hundreds. Same code. Write the positioning statement before thinking about a number; the number is mostly decided once you have.

Per product: list every plausible alternative and what it costs, including “do it by hand” (hours × their wage). Pick the segment whose alternative is most expensive and whom you can credibly reach. Position against that alternative explicitly. Your ceiling is a slice of the gap — 10–30% of the quantified value is the Monetizing Innovation convention, and it survives contact with reality.

#When the alternative is a competitor

If a competitor exists, they’re the reference alternative — the anchor is their pricing page. You have three moves:

1. Cheaper, same job. The default instinct and usually the worst move. Price signals quality, so the cheap clone reads as the knockoff. And you’ve started a war where the winner is whoever can bleed longer.
2. Premium, narrower. Same job, one segment served much better, priced above them. Their breadth is your opening: a horizontal tool serves everyone shallowly, so pick the vertical whose alternative is most expensive and go deep — the incumbent can’t follow without rebuilding their product for your niche.
3. Sideways. Reposition so the comparison stops applying — a different job, a different alternative, a different anchor. This is the only move that doesn’t concede the anchor to them.

Against a funded competitor. Their arithmetic is not yours. They can run negative unit economics for years — free tier, sales team, ads — because they’re spending investor money to buy market share. Two consequences:

• Never match their subsidies. Their free tier is a loss leader financed by a fund. Yours would be financed by your savings. Matching it is entering a bleeding contest against someone with a transfusion line.
• Their funding forces them upmarket — that’s your opening. The board needs growth; growth at their size needs enterprise deals; enterprise deals grow gates, admin layers, “talk to sales,” complexity. The small, simple end of their market gets structurally abandoned — not by oversight, by their own arithmetic. (This is Christensen’s Innovator’s Dilemma mechanism, running in your favor for once.) Sit exactly there: simple, honest public pricing, generous where they nickel-and-dime, a named human answering email. Compete on what funding can’t accelerate — focus, taste, speed, trust.

Against another bootstrapper. Both of you have real unit economics, so a price war destroys both and neither can subsidize past the other. Don’t fight on price at all — if they undercut you, their low price caps what they can afford in quality and support; go up, not down. Segment sharper: two bootstrappers almost always means the market has room for both, and the one who picks the narrower, richer segment keeps the margin. The real competition between bootstrappers is rarely price anyway — it’s distribution. Win the channel (SEO, community, integrations), not the discount.

#Decision 2 — Who pays

Three regimes, set by whether the payer, the user, and the chooser are the same person:

• B2C — payer, user, and chooser are one person. Price fights personal discretionary money at full pain-of-paying: low ceiling, high elasticity, and the psychology does most of the work.
• B2B bottom-up — the user chooses; the company pays eventually. Individual value → team spread → someone with a card. The solo-founder default.
• B2B top-down — the chooser isn’t the user. You’re selling to the chooser’s incentives — risk, compliance, looking good — and the user’s experience barely touches the purchase. Needs sales capacity. Don’t build these solo unless one contract justifies you personally being the sales team.

The mechanism to exploit in bottom-up B2B: a user spending company money feels almost no pain of paying — it’s not their mental account — but they do face process friction, and the thresholds are load-bearing:

• Under ~$50/mo — no approval, just the corporate card. Purchase is a non-event; price here for zero-touch.
• ~$50–500/mo — a manager signs off. The buyer needs a one-paragraph justification — write it for them.
• Past ~$1–2k/mo — procurement, security review, legal. Each deal costs you days.

Price picks the sales motion, not the other way around. A $30/mo product can’t afford a demo call — the payback math forbids it. A $2k/mo product can’t survive on self-serve — procurement demands a human. Between them lies the dead zone: too expensive for a card, too cheap to fund a sales process. Products priced there starve. If your value math lands in it, move — repackage down under the expense threshold, or up (annual, team-wide, compliance features) until sales touch pays for itself.

Budget cycles: top-down money is easiest at fiscal year-end (use it or lose it) and hardest mid-freeze. Bottom-up expensing doesn’t care about the calendar — one more reason it’s the solo default.

Not solo? A funded team can staff the dead zone away — inside sales makes $200–800/mo deals workable, and top-down becomes real once someone can live inside procurement cycles. One rule survives funding: sales is hired to scale a motion the founder already made repeatable, never to discover one.

#Decision 3 — What the price scales with

The value metric is the unit your price grows along — seats, projects, API calls, revenue processed. It’s the most leveraged pricing choice you’ll make because it runs forever: right, and revenue grows automatically as customers succeed; wrong, and you either subsidize your biggest users or overtax your smallest until one side leaves.

Four tests, in priority order:

1. When the customer gets more value, does the metric grow? (This is what makes NRR > 100% possible.)
2. Can the buyer predict their bill? Unpredictable bills convert terribly — fear of the open-ended loss.
3. Does it grow with success, not with pain? Never meter the thing you want them doing more of while they’re forming the habit.
4. Cheap to measure, hard to game. If sharing a login beats buying a seat, your metric taxes collaboration — the one behavior you want most.

Tests 1 and 2 pull against each other; the whole decision is that trade.

• Seats are predictable and fair only when value is per-human. They fail — this is the current failure mode — when the product is an agent doing work instead of humans: value goes up while seats go down. A product whose pitch is “replaces labor” cannot price on seats; it would be metering its own value proposition backwards.
• Usage tracks value and cost but hands the bill-uncertainty to the buyer and makes every unit hurt — so users self-ration, which starves the habit.
• Outcomes (per booked meeting, per resolved ticket) are perfect on test 1 — and rise or fall entirely on attribution, which Ramanujam names as the unlock. When the customer disputes credit, outcome pricing collapses into a fight; when your system logs the outcome itself, it becomes the best metric there is. It’s arriving now because the proof got automatic: Intercom’s Fin charges per resolution since the AI can show it closed the ticket. Default to it only where the outcome is unambiguous and you own the record of it.

AI costs force the issue: with real variable cost, flat pricing means your most enthusiastic users are your lowest-margin users — adverse selection where love loses you money.

Default: hybrid. A flat base fee (predictable, covers fixed costs, decouples payment from use) plus usage on the cost-bearing dimension, sold as prepaid credit packs, not a meter that bills afterward. Credits win three ways at once: the pain of paying happens once up front, then use feels free — the opposite of the meter’s self-rationing; cash arrives before the cost does; and credits bought but never spent are pure margin. Billing in arrears is right only for infrastructure sold to engineers who own the budget — Stripe and AWS earn it; that’s a segment fact, not a general rule.

#Decision 4 — Finding willingness to pay

The value of information is the cost of the mistake it prevents. A 2× mispricing compounds over every sale forever, and most founders spend zero hours measuring it — so the first few hours of pricing research are the best-paid hours in the company. But it saturates fast. Budget days, not weeks. Ten good interviews beat zero by an enormous margin, and beat a 500-response survey by less than you’d think.

Not solo? Budget and traffic raise the ceiling on worthwhile measurement — real conjoint studies, pricing firms, live A/B tests. The logic doesn’t change: spend until one more observation stops changing the decision. It just saturates later.

#The interview problem

Interviews have an observer effect. In front of you, the user is performing: paying attention because you asked, reasoning carefully because that’s what interviews reward, being agreeable because you’re a human being watching them. The real purchase happens later — alone, at 11pm, half-emotional, driven by frustration or ambition or wanting to be the kind of person who has this. You interviewed the rational narrator; the impulsive one buys.

The distortion doesn’t even point one direction. Politeness inflates enthusiasm — “I’d totally pay for this” costs nothing to say. Performed rationality deflates emotional willingness to pay — nobody says “I’d buy this to feel powerful” out loud — and inflates feature-talk (“I’d need SSO first,” says a man who will never set up SSO). So interview numbers are unusable in both directions. What survives the observer effect:

• The past. “Walk me through the last tool you bought in this category — what triggered it, what did you compare, what did it cost?” A memory can’t be performed the way a prediction can. This is The Mom Test in one rule: past specifics, never future hypotheticals.
• Money already spent. What they pay today for the alternative, in dollars and hours. Spent money doesn’t flatter you.
• Behavior you can watch. The fake door: a landing page with real prices and a working “start trial” button, live before the product exists, click-through measured per tier. A deposit — “$20 locks the beta price” — outweighs an hour of talk. These are the only instruments here that measure what people do instead of what they say.
• Reactions, not commitments. Never “would you pay $50?” — that invites the performer. Instead: “it’s $50 a month” — then silence, and read the flinch. “Acceptable, expensive, or prohibitive?” asked as reaction gets you a range without asking them to promise anything.

Use interviews for what they can measure — the reference alternative, whether the pain is real, which features matter. Get the price itself from behavior.

#Sorting features: leaders, fillers, killers

From those same conversations, classify every feature (Monetizing Innovation’s taxonomy):

• Leaders drive the purchase — people would pay for them alone. They gate your paid tiers.
• Fillers are nice but move no money. Bundle them freely; they make tiers feel full.
• Killers actively repel a segment when forced into their bundle — the compliance suite that makes the indie plan feel corporate and overpriced, the AI feature a privacy-sensitive buyer reads as a liability. Killers are the non-obvious category and the reason “just include everything” fails. Unbundle them or make them add-ons.

You can’t sort these without the interviews — which is why measuring comes before packaging.

#Cheap instruments, in order

1. Ten to fifteen interviews in the target segment (above).
2. Van Westendorp’s four questions — at what price is this too cheap to trust / cheap / expensive / prohibitive — across ~30 people gives a range, and the “too cheap” floor. A prior, not an answer.
3. Three or four package+price combinations, force-ranked. You don’t need a demand curve — you need to know which features carry the willingness to pay.
4. The fake door, for anything that costs more than two weeks to build.

#Decision 5 — The model

Two independent choices hide in “how should I charge,” and conflating them causes most of the confusion: how money recurs and how people start. Pick recurrence from the shape of the value and of your costs; pick the start from the funnel math.

#How money recurs

• Subscription — pay for continued access. For when the value and your cost are both ongoing: hosted, updated, stored. If the value is a one-time transformation, users churn the moment the job is done.
• Subscription + credits (hybrid) — flat base plus prepaid usage. For real per-use COGS (AI) on top of ongoing value. This is the default; see Decision 3.
• Pure usage — bill per unit, after use. For infrastructure sold to engineers who own the budget. Anywhere else, bill-fear kills conversion and self-rationing kills the habit.
• Pay once — one price, keep it forever. For a discrete transformation with ~zero marginal cost, sold to the subscription-fatigued. The trap is shipping free updates forever: cost forever against revenue once.
• Pay once + paid versions — buy 4.0; 5.0 costs again. For desktop-class tools with big periodic releases — viable exactly as long as each version has something worth paying for.
• Perpetual + update year (the Sketch model) — keep what you bought forever; renewal buys another year of updates. For local-first tools, low server cost, trust-sensitive buyers. Every renewal must be re-earned with visibly shipped value.
• Lifetime deal — sell the whole LTV for a few months’ revenue, cash today. For launch financing only: capped quantity, near-zero marginal cost. Any real COGS turns a lifetime customer into a perpetual loss.
• Transaction fee / rake — a % of money flowing through. For when you facilitate the transactions; the value metric aligns perfectly — until the volume routes around you.

Three of these deserve a longer look: pay once, the Sketch model, lifetime deals

Pay once runs on mental accounting: a one-time purchase comes out of the “buying a tool” account, a subscription out of the “obligations” account, and the first is far easier to open — subscription fatigue is real and growing. The trade is brutal though: LTV = price, NRR = 0, and every month starts at zero revenue. The arithmetic only closes if your costs are also one-time — no hosting, no inference, no support treadmill. A pay-once product with recurring AI costs is a subscription you forgot to charge for. A subscription is really an EMI in reverse — an installment plan with no final payment and no owned asset at the end — which is why it can feel like a debt that never clears. Kaufmann’s Personal MBA names the escape: reframe the recurring charge as an option (ongoing access to a capability you want available — gym, insurance, standby), not installments on a thing, and the “when do I finish paying?” instinct never fires.

The Sketch model — perpetual license, renewals buy updates — is the fairness-optimal version of pay-once, and it’s underrated. Nothing is ever taken away: stop paying and you keep what you bought, so there’s no hostage dynamic, which buys enormous trust with exactly the audience (designers, developers) most allergic to rent-seeking. The discipline it imposes is the honest kind: a renewal isn’t retention, it’s a fresh purchase decision made against the value you visibly shipped this year. You re-earn every customer annually. Choose it when the product is local-first and your server costs are near zero; avoid it when value depends on hosted compute you pay for monthly. (JetBrains runs the inverted variant — subscription that matures into a perpetual fallback license after 12 months — same fairness property, smoother revenue.)

Lifetime deals are financing, not pricing: you’re selling the entire future of a customer for a few months of revenue, today. That can be rational exactly once — launch capital plus an initial user base, in capped quantity, on a product whose marginal cost rounds to zero. With AI COGS it’s a debt that compounds: every lifetime customer is a small negative annuity you can never cancel. There’s a legitimate psychological edge worth naming, with a guardrail: at a moment of earned delight — the user just realized real value — a lifetime or annual offer converts hard, because it captures peak WTP and deletes every future churn decision at once (each renewal is a fresh chance to quit; kill them all). The guardrail is that the peak must be earned, not manufactured; a lifetime deal sold on a fake countdown is the sleazy quadrant, repaid in refunds and reputation. And the COGS test still binds — offer lifetime only where a lifetime customer can’t bankrupt you.

#How people start

• Opt-in trial — endow, then expire; price visible from day one. The default whenever value proves itself in days.
• Card-upfront trial — a commitment filter. For qualified traffic, high cost per trial, sales-adjacent motions.
• Reverse trial — start on the full paid tier, downgrade to free. For when you can justify a free tier and the premium features endow fast.
• Free tier (freemium) — the zero-price effect plus viral seeding, forever. Only when one of the three freemium mechanisms below holds, with numbers.
• Straight to paid — price as the quality filter. For small markets, high per-user cost, premium positioning.

The reverse trial is the trial and freemium composed, and worth understanding because it fixes each one’s weakness. The user starts with everything, so the endowment builds on premium features — the ones you actually sell. When time runs out they aren’t evicted, they’re demoted: the loss is felt (loss aversion does the selling), but they stay in the system on the free tier, where the viral loop keeps running and a second conversion moment can arrive later. The costs: the free tier must justify itself anyway — every freemium test below still applies — and the downgrade is a fairness event, so frame it from day one (“you’re on Pro until the 14th”), never as a surprise. One honesty note: the model is fashionable but thinly measured — only ~7% of products in the one public survey use it, benchmarking at 4–6% good / 8–12% great, no better than gated freemium. The case for it is the mechanism, not the data yet.

#The free decision

Free buys three things: volume (the zero-price discontinuity), viral seeding (free users power the invite loop), and content or data that improves the product. It costs three: m per free user per month (real again, thanks to AI), anchor destruction — your reference price becomes $0 and every future price is judged as an increase from free — and support drain, the resource a solo founder actually runs out of first.

Rules:

• Freemium only if at least one holds, with numbers: (a) free users mechanically generate paid ones — a real loop where invites are intrinsic to using the product, not a hopeful share button; (b) free users’ content or data makes the product better for payers; (c) the free tier is your marketing channel and its cost-per-conversion beats your next-best channel. If none holds, freemium is a subsidy to non-buyers, permanent COGS, and an anchor at zero — and most products fail all three tests.
• Trial whenever the product proves its value within days. A trial captures the zero-price effect at entry without setting your reference price at zero — the price was always visible; the free part was always framed as temporary. For most B2B and prosumer products, trial strictly dominates freemium.
• Paid only (or trial with card up front) when the variable cost is high, the market is a few thousand companies (a free tier adds noise, not funnel), the motion is sales-assisted, or the segment reads free as “toy” and price as quality.

The contrarian position, stated plainly: “freemium is good for product-led growth” confuses product-led growth (the product sells itself through use) with free (a price point). A 14-day full-featured trial is product-led. Freemium made sense when free users cost nothing and virality was common; both premises are now usually false. Default to trial. Freemium must be affirmatively justified by a named mechanism with numbers — otherwise it’s cargo cult.

If you do run freemium: give the free tier a dollar budget, keep the expensive capability out of it or capped at single-digit units, and re-check quarterly as model costs move.

#A note on AI token models

AI products face a fourth axis the frameworks above don’t cover: who holds the model-provider relationship. Three options, ranked by monetization today:

• Buy the tool + credits at a margin — you resell inference at markup (the hybrid default from Decision 3). Best monetization right now, but only because the ecosystem is immature; you carry COGS risk and the markup compresses as model prices move.
• BYO keys — the user brings their own API key; you charge only for the software. Clean (you never touch inference cost or risk) but niche: only technical users have keys, and you forfeit the markup and all usage visibility. Right for dev tools, wrong for mass market.
• Centralized token wallet (“sign in with ChatGPT” for tokens) — doesn’t exist yet, and here’s the strategic point: if it arrives, it kills your token markup. A universal token SSO turns you into a thin client on someone else’s wallet.

The lesson: token markup is a temporary margin, not a moat. Price your tool on the value of the software and workflow; treat reselling inference as an edge that may vanish the moment a provider ships a universal wallet. Build so the business still works when tokens are a pure pass-through — because that’s the direction maturity points.

#Decision 6 — Where the gates go

Two principles fall straight out of the arithmetic. A gate before the value moment multiplies your worst funnel rate by your paywall rate — you’re charging admission to the demo. A gate on the viral action cuts the invite loop to payers only — you’re taxing the exponent to protect a linear term. So: gate after value, never on spread, along the depth dimension your best customers grow into — which is the value metric from Decision 3, and by construction it tracks willingness to pay.

Positions on the contested calls:

• Time or usage? Usage, when the value event is countable. “10 projects” ends the trial exactly when value has been proven for that user — whether that took three days or three months. A 14-day box expires slow evaluators before their value moment and lets fast ones strip-mine it free. Time-box only when value is continuous and uncountable. Usage cap with a time backstop is legitimate, not a cop-out.
• Per person or per workspace? Per workspace. Per-person trials in a team product reset the clock with every teammate — the trial never coherently ends — and the team’s accumulated work is the endowment your conversion depends on; fragmenting it per person throws the asset away.
• Gate invites? Never the receiving side. Viewing, commenting, joining — free, without an account if you can manage it. That’s the top of the viral loop. Gate the creation and administration side instead: how many projects the team runs, admin controls, SSO. Capacity, not connectivity. Figma’s free-viewers, paid-editors split is the canonical answer, and it falls straight out of the funnel math.
• Try before signup? Yes, whenever a real slice of value fits in one anonymous session and the per-session cost is tolerable. An account form is a gate in every sense that matters — a drop-off rate paid before any value is felt. The right sequence is value → account → payment: let them make something, then the account is how they keep it. Signup stops being a toll and becomes a save button, and the endowment does the converting. If AI cost makes anonymous sessions expensive, give one cheap-but-real unit of value, not zero.

#Decision 7 — Tiers and the ladder

Tiering exists because you can’t see willingness to pay — so you build a menu on which customers sort themselves. The economics textbooks call it second-degree price discrimination; the pricing page calls it good-better-best.

• Three buyable tiers. Fewer captures too little of the WTP distribution; more causes comparison paralysis. An “Enterprise — talk to us” line above them is free anchoring even if nobody ever calls.
• The top tier is an anchor first, a product second. Edge-aversion pushes buyers to the middle, so price the top high enough that the middle looks moderate — and build the middle as the tier where you actually want most customers, carrying the leaders your segment named.
• Leaders gate tiers. Fillers pad them. Killers get quarantined into add-ons. Tier boundaries follow segment boundaries — indie, team, business — so a buyer recognizes themselves in one glance, not arbitrary quantity breakpoints.
• Every tier needs a fence — the thing that stops a high-WTP buyer from happily living on the cheap plan. A fence is a feature or limit the rich segment can’t do without and the poor segment doesn’t miss: the agency needs client workspaces, the team needs SSO and audit logs, the indie needs neither. No fence, and your tiering collects the low price from everyone who could have paid the high one. (The concept is from Nagle’s pricing textbook; Information Rules covers the same move as “versioning” — deliberately building the good, cheaper version so the market segments itself.)
• The upgrade trigger is the limit itself, hit during successful use. The customer grows, bumps the cap, upgrades — no persuasion, and NRR does the rest. Design each tier’s limits so your target segment’s success path crosses them. And make the limit soft at the moment of impact: let them finish the task in hand; the next one needs the upgrade. A hard wall mid-task pairs maximum payment pain with maximum frustration — it reads as hostage-taking. Hard stops are honest only where the marginal cost is real and immediate (the AI credits are actually gone) — “you used what you bought” is a frame fairness accepts.

The friction test. Customers accept limits that trace to a real cost you bear or a real value difference between tiers. They punish limits that exist only to create pain that money relieves — maybe not today, but the day they notice, they reclassify you as an adversary, and every future interaction becomes a fight. So run every limit through one question: could you explain why it exists to the customer’s face, without embarrassment? “More AI usage costs us more” — passes. “More seats, more humans served” — passes. Artificially slow exports, a 3-project cap where projects cost you nothing, deleting data on downgrade — none of them survive the question. Manufactured friction converts in the short run; it converts trust into revenue at a terrible exchange rate, and churn — the denominator under your entire LTV — collects the bill.

Expansion design is one choice: pick the dimension your successful customers naturally grow along — teammates, volume, workspaces — and make that the billing dimension. Everything else is packaging.

#Decision 8 — Raising prices

You will underprice at launch. Under uncertainty that’s even correct — raising from a position of delivered value is cheap; walking back an overreach is expensive. So plan the raise at launch instead of improvising it in year two.

One precondition: you can only raise toward value you can defend. Pricing power is downstream of a moat (Helmer’s 7 Powers) — accumulated data, switching costs, a brand the segment trusts. If switching is free and a clone is equal, a raise just hands your customers to the clone.

• Raise on new customers freely and continuously. They have no reference price with you, so there’s no fairness event. The pricing page is an experiment surface (this is also your elasticity probe).
• Existing customers need justification, notice, and an escape valve. A frame fairness accepts (new capability shipped, real costs rose — the AI-costs story is currently both true and legible), 60–90 days notice, and an escape valve: “lock your current price by going annual.” That last one converts a fairness threat into a gift — and gifts get repaid (Cialdini’s reciprocity) — while collecting a year of cash in the same move.
• Time-box the grandfathering. Permanent grandfathering feels generous and builds a shadow price book you can never sunset; the forced migration years later is a worse fairness event than “your price is locked for 12 months” honestly labeled today.
• Small and regular beats rare and large. A single-digit raise every year stays under the outrage threshold and resets the reference price each time. A 60% correction after five frozen years is a maximal outrage event — even when the cumulative math is identical.

What private equity knows. PE firms buy under-monetized software and run a standard playbook: immediate 20–50% raises, perpetual licenses forced to subscription, seat audits, unbundling features customers already had, support tiers, auto-renew with narrow cancellation windows. Sort it with the fairness lens:

The PE playbook, sorted into copy / don't copy

• Copy: raising prices toward delivered value (most long-lived software is genuinely underpriced — founders anchor on their launch price forever); charging for expensive-to-serve things; pruning uneconomic legacy deals, with notice; annual terms with fair renewal.
• Don’t copy: unbundling what customers already possessed — that’s a taking, and losing an owned thing hurts double; auto-renew traps and cancellation windows; audits as a revenue line; raises calibrated to how hard leaving would be.

The test: sound pricing moves price toward value delivered. Rent extraction moves price toward cost of leaving. Ask which number the increase was computed from. PE can afford the second because the fund exits before the trust decay lands. You keep your products and your name — for a permanent owner, staying inside the fairness line is arithmetic, not ethics.

#Cross-cutting calls

Annual vs monthly. Annual prepay floors churn at one decision per year (a hyperbolic LTV gain), collects cash before you’ve paid to serve it, and hurts once instead of twelve times. Worth a real discount — 15–20%, roughly two months. Default the toggle to annual; never go annual-only at self-serve prices — monthly is the low-commitment door the wary need. B2C caveat: a deep annual discount harvests prepay from people who’ll never use month three; the refunds and resentment arrive later.

Cancellation. Exit friction prices into entry: buyers discount your offer by what they expect leaving to cost, so easy exit raises entry conversion — easy exit is what makes auto-renewing card payments acceptable at all. One-click cancel, a real pause option (a paused customer who returns re-enters at zero CAC; a cancelled one is gone), one honest save-offer at most. Retention mazes are manufactured friction applied right where scrutiny peaks: weeks of revenue, permanent damage.

Localization. One global USD price overcharges most of the world down to zero volume. Purchasing-power-adjusted regional pricing sells the same near-zero-marginal-cost bits to whole new sections of the demand curve — nearly pure found margin. Two caveats: VPN arbitrage (below ~5%, tolerate it as the cost of the found revenue), and AI costs — your inference bill is not purchasing-power-adjusted, so check regional prices still clear your variable cost. Cosmetic localization — currency display, local payment methods (UPI, Pix, iDEAL) — is underrated and free of fairness risk: friction removed without touching price.

---

To price a real product with all of this: the runbook. Next: 4 — The benchmarks — how many customers and visitors these choices actually require, and what they’re worth at exit.