# Sell Lifetime Deals on Next.js: $199 Beats $15/mo

> $199 once beats $15/month for solo templates: lifetime math, Dodo one-time checkout, 60-second grant. The full playbook inside.

Source: https://boringpush.com/blog/sell-lifetime-deal-nextjs-dodo

## MRR theater for businesses that aren't venture-scale

The indie script says chase MRR: price at $15/month, watch the chart climb, celebrate each plateau on social media. Then month four arrives with 8% churn, a dunning queue, and growth that needs paid acquisition to outrun cancellations.

For venture-backed teams, MRR compounds beautifully. For a solo founder selling a template, the subscription machinery — trials, proration, dunning, win-backs, cancellation flows — costs more attention than the product earns. You built a billing company that happens to sell a starter kit.

Sell lifetime deal nextjs thinking cuts the knot: one price, one charge, customers forever. The chart goes up and stays up.

## Subscription vs lifetime for solo sellers

| Axis | $15/mo × 200 users | $199 once × 200 users |
|---|---|---|
| Cash collected year 1 | ~$28k (after churn) | ~$40k (upfront) |
| Billing support load | Weekly (cards, plans) | Near zero |
| Churn existential checks | Monthly | Never |
| Price-increase lever | Grandfathering maze | v2 at new price |
| Worst month | Churn spike + tickets | Quiet (sold is sold) |
| Buyer objection | "Another subscription?" | "Worth $199?" (once) |

Three details make lifetime win specifically for templates and kits:

1. **Buyers hate subscriptions for artifacts.** Nobody wants to rent code or a shipping kit — it feels like paying monthly for a hammer. One-time pricing matches the mental model (buy the tool, own the tool), which is why lifetime converts better on template landing pages.
2. **Support without billing is half the job.** Lifetime buyers email about usage, never about cards. Subscription sellers staff a billing desk; lifetime sellers answer product questions and close the laptop. Same headcount (one), wildly different weeks.
3. **Launch spikes become runway.** A front-page launch selling 150 lifetime deals at $199 is $30k in a weekend — a year of solo runway in 48 hours. The same launch on subscriptions is $2k MRR and a churn clock. Spikes favor the once-priced.

Subscriptions win for ongoing-cost products. Artifacts — templates, kits, lifetime tools — should price like artifacts.

## Sell lifetime deal nextjs playbook

BoringPush sells itself this way ($199 once via Dodo), so the playbook below is the store eating its own cooking.

**Step 1 — Price the deal on buyer math, not cost-plus.**

```md pricing logic (not code — arithmetic)
Anchor: comparable subscriptions ($15/mo → $180/yr, forever).
Deal: $199 once ≈ 13 months of the alternative, then free forever.
Launch: $129 early (first 100) → $199 standard → $299 v2.
Scope line: "v1.x updates + email support. v2 is separate."
```

Early pricing rewards speed (first 100 fund the launch), standard pricing holds the line, v2 reprices the installed base without touching old deals. The scope line prevents forever-everything expectations — generosity with boundaries outlasts generosity without them. Price tests swap the product row, never code.

**Step 2 — Charge once through Dodo's one-time checkout.**

Define the sale as data: Dodo as the provider, a one-time purchase, your product ID, $199 and USD. Checkout then goes to Dodo's hosted page, and the webhook grants access exactly once.

Hosted checkout means zero card-handling code and global methods out of the box; the webhook reuses the identical exactly-once guard as subscriptions (namespaced ref, product-row price, receipt on first write). The Dodo template post details the adapter; this post is the strategy it serves. One-time webhooks retry like all webhooks — the guard holds them to one grant.

**Step 3 — Grant fast, with receipt and scope.**

Time the buyer journey on staging: click Get, pay on Dodo's page, wait for the webhook to grant access, then check that the success page shows the order with download and docs links. Measure it yourself rather than promising a number.

Immediacy converts: every minute between payment and access spends launch-day trust. The receipt email (Resend) carries download, docs, and the scope line — the three things buyers need before buyer-remorse sets in. Refund path tested quarterly: one event revokes access and marks the row, same transaction, no orphans.

That's the whole trick — launches that pay for the year in a weekend.

## Sell lifetime deal nextjs launch math

| Launch weekend | Subscription pricing | Lifetime pricing |
|---|---|---|
| 150 buyers | $2.2k MRR + churn clock | $30k cash, kept |
| Support week 1 | Billing questions begin | Usage questions only |
| Month 6 revenue from cohort | ~$11k (after churn) | $30k (already banked) |
| Price increase path | Grandfathering fight | v2 at $299, cheered |
| Founder attention | Billing desk staffed | Product work resumed |

The cons, listed: lifetime forfeits expansion revenue — no upsells to the installed base except v2, no price-increase lever on existing buyers.

BoringPush answers with stacking (v1, v2, add-on kits each priced once) and affiliates (owners sell better than ads). Recurring revenue compounds for teams; upfront cash compounds for solos who reinvest it in the next artifact. Pick the compounding that matches your headcount.

## FAQ

### How do I sell lifetime deal nextjs without training buyers to wait for discounts?

Price on a published ladder (early → standard → v2) with dates, not surprises: $129 for the first 100, $199 after, announced upfront. Predictable escalation converts fence-sitters instead of training discount-waiters.

Flash sales teach waiting; ladders teach buying. Never discount below the early price — the first buyers' trust is worth more than any spike.

### What belongs in the lifetime scope line?

Version scope (v1.x updates included, v2 separate), support channel and speed (email, 48h), and explicit exclusions (no custom work, no SLAs). Three lines that prevent 90% of scope disputes. Generous inside the lines, firm at the border — lifetime goodwill survives on clarity, not on yes-to-everything.

### Should lifetime deals include future v2 for free?

No — v2 is the business model's second act. Early v1 buyers get loyalty pricing on v2 (not free), which rewards earliness while funding continued work.

Free-forever-across-versions converts one launch into permanent obligation. The ladder ($129 → $199 → $299 v2) tells buyers the story upfront: buy early, save always, upgrade willingly.

### How do affiliates fit a lifetime model?

Perfectly: one-time payouts per sale (no recurring commission accounting), owner-buyers as the best affiliates (they demo what they use), tracked via first-touch attribution codes. Lifetime economics make affiliate math trivial — fixed bounty per $199 sale, paid from margin that has no churn tail. Set 30–40%, pay monthly, watch owners sell.

### What if lifetime buyers demand refunds months later?

Honor generously within the stated window (30 days, no questions), firmly after it (scope line governs). The refund webhook path revokes access automatically either way — policy lives in support tone, not in code branches.

Lifetime refund rates run lower than subscription churn precisely because the decision was deliberate. Trust the deliberateness.

### Can lifetime coexist with a subscription tier later?

Yes — position them as different products: lifetime for the artifact (template as-is), subscription for the service layer (hosted version, team seats, priority support). Same codebase, two offers, namespaced product rows.

The subscription post covers recurring mechanics; the lifetime base funds building it. Stack, don't convert.

## Keep reading

- [Next.js + Dodo $199 Once: Beat $15/mo Forever](/blog/nextjs-dodo-payments-template) — the checkout adapter this strategy runs on
- [Stripe vs LemonSqueezy vs Dodo: Pick Wrong, Pay for a Year](/blog/stripe-vs-lemonsqueezy-vs-dodo-nextjs) — the rail comparison behind the Dodo pick
- [Take Money 3 Ways, Write Checkout Once](/blog/three-payment-rails) — the architecture that keeps options open