Recurring billing looks simple from the outside — charge the card every month — and is quietly one of the most failure-prone parts of a SaaS business. Industry experience consistently shows that a meaningful share of recurring charges fail each cycle (expired cards, insufficient funds, bank declines), and involuntary churn from failed payments often rivals voluntary churn. A SaaS doing $100k MRR with 5% monthly failed-payment churn is losing $5,000 every month to a solvable engineering problem.
This guide compares the main implementation approaches for SaaS recurring billing, then covers the four operational areas where billing systems actually differ: dunning and retries, usage-based billing, invoicing, and tax. The goal is to help you pick an architecture that matches your stage — not to crown a single winner.
Implementation Approaches: Four Architectures
1. All-in-one billing platforms (Stripe Billing, Chargebee, Recurly, Paddle)
These platforms own the subscription lifecycle: plan definitions, trials, proration, upgrades/downgrades, dunning, and hosted invoices. You integrate their API or hosted pages, and they handle the recurring charge logic.
Best for: teams that want billing correctness without building it. Stripe Billing is the default choice when you're already on Stripe; Chargebee and Recurly add multi-gateway support (useful if you process through several PSPs); Paddle operates as merchant of record, absorbing sales tax/VAT compliance entirely at the cost of a higher revenue share — check current rates on each vendor's site.
Trade-offs: platform fees stack on top of processing fees (typically 0.5%–0.9% of billing volume for billing layers; merchant-of-record models cost more), and deep pricing-model changes can require migrating subscription objects, which is never fun.
2. Payment-gateway-native subscriptions
Most gateways (Stripe, Braintree, Adyen, and others) offer native subscription objects without a separate billing layer. You get recurring charges, basic retries, and webhooks, but build plan logic, proration, and dunning email flows yourself.
Best for: straightforward pricing (a few flat plans, monthly/annual) where a billing platform's extra fee isn't justified.
3. Build-your-own on top of raw payment APIs
You store payment methods (via tokens — never raw card data), run your own scheduler, and charge via API. This gives full control over retry logic, pricing experiments, and multi-gateway routing.
Best for: companies with unusual billing models (complex usage metering, marketplace splits) or volume large enough that billing-platform fees exceed an engineer's salary. Don't start here.
4. Crypto / stablecoin recurring billing
Crypto has no pull-payment equivalent — a gateway cannot debit a customer's wallet — so "recurring" is implemented as prepaid periods: the customer pays for 1/3/12 months up front, and the system sends renewal reminders before expiry. Non-custodial USDT gateways (such as USDTGate) automate the payment detection and confirmation side, crediting the subscription on-chain within minutes.
Best for: crypto-native audiences, customers in regions with low card penetration, and sellers who want zero chargebacks on subscriptions. The prepay model also eliminates failed-payment churn entirely — the trade-off is that customers must actively renew, so voluntary churn measurement becomes more honest and reminder flows become critical.
Comparison Table
| Approach | Setup effort | Extra fees | Dunning built-in | Usage-based support | Chargeback exposure |
|---|---|---|---|---|---|
| All-in-one billing platform | Low | Billing fee on top of processing (check current rates) | Yes, configurable | Strong | Yes (card rails) |
| Gateway-native subscriptions | Medium | Processing only | Basic retries | Basic | Yes |
| Build-your-own | High | Processing only | You build it | Whatever you build | Yes |
| Crypto prepaid (USDT) | Low to medium | Low flat gateway fee (check current rates) | N/A (prepay model) | Via your own metering | None |
Dunning and Failed-Payment Recovery
Dunning — the process of recovering failed recurring charges — is where billing systems earn their keep. A competent dunning setup has three components:
1. Smart retries
Retry timing matters more than retry count. Card declines split into soft declines (insufficient funds, temporary holds — retryable) and hard declines (stolen card, closed account — stop immediately). Retrying hard declines angers issuers and can raise your decline rates account-wide. Common practice: 3–4 soft-decline retries over 10–14 days, with timing adjusted to the decline reason and, where your platform supports it, network-level signals about when the card is likely to have funds. Stripe, Chargebee, and Recurly all offer machine-learning-tuned retry schedules; building this yourself is possible but rarely worth it early.
2. Account updater
Cards expire and get replaced. Account-updater services (offered via the card networks through your PSP) automatically refresh stored card details. This alone recovers a large share of what would otherwise become failed payments — enable it wherever available.
3. Pre-dunning and customer communication
Email the customer before the charge when a stored card is nearing expiry, and immediately after any failure, with a direct link to update payment details. Sequence suggestion:
- Day 0 (failure): notify immediately, keep service active.
- Day 3: second email + in-app banner.
- Day 7: third email, warn of upcoming suspension.
- Day 14: downgrade or suspend, keep data, keep the door open for reactivation.
A well-tuned dunning flow typically recovers a substantial share of failed payments; the difference between "no dunning" and "configured dunning" is often several percentage points of MRR.
Usage-Based and Hybrid Billing
Pure flat-rate subscriptions are giving way to usage-based (per API call, per seat-hour, per GB) and hybrid (base fee + overage) models. The architectural implications:
- Metering belongs to you. Even with a billing platform, you own event collection and aggregation. Design idempotent, auditable event pipelines — billing disputes start with "your meter is wrong."
- Decide real-time vs end-of-cycle rating. Real-time usage display reduces bill shock and disputes; end-of-cycle calculation is simpler. Most teams do end-of-cycle for the invoice and approximate real-time for the dashboard.
- Guard against runaway bills. Spending caps and threshold alerts protect customers and reduce disputes and chargebacks.
- Prepaid credits are the crypto-compatible option. If you want usage-based billing on stablecoin rails, sell credit bundles that draw down with usage — this maps naturally to push payments.
Invoicing and Tax
Invoicing: B2B SaaS customers need compliant invoices (sequential numbering, tax IDs, correct legal entity details). Billing platforms generate these automatically; if you build your own, treat invoice generation as a separate subsystem with immutable records, not a PDF template.
Tax: SaaS is taxable in far more jurisdictions than founders expect — US state sales taxes increasingly cover SaaS, the EU requires VAT based on customer location, and many other countries have digital-services taxes. You have three realistic paths:
- Merchant of record (Paddle, Lemon Squeezy, Polar): they are the legal seller and handle tax globally. Simplest, most expensive per dollar.
- Tax automation (Stripe Tax, Avalara, TaxJar) on top of your own processing: you remain the seller; the tool calculates and reports, you register and remit where required.
- Manual: viable only below registration thresholds. Track your sales by jurisdiction — threshold surprises are common.
Whichever path you choose, decide before you cross thresholds, not after; back-registration penalties are an avoidable expense.
A Decision Guide by Stage
- Pre-product-market-fit: gateway-native subscriptions or a billing platform's entry tier. Optimize for speed of pricing experiments, not fee minimization.
- $10k–$100k MRR: billing platform pays for itself via dunning recovery alone. Enable account updater and smart retries. Decide your tax path now.
- $100k+ MRR or complex pricing: evaluate build-vs-buy on fees at your volume; consider multi-gateway for redundancy. Add a stablecoin prepaid option if you have meaningful international or crypto-adjacent demand.
Conclusion
Recurring billing is infrastructure, and infrastructure decisions compound. Start with an architecture that gives you correct dunning and invoicing out of the box — for most teams that's a billing platform or gateway-native subscriptions — and add usage-based sophistication only when pricing strategy demands it. Treat failed payments as a recoverable system problem (account updater + smart retries + communication) rather than inevitable churn, and make your tax path an explicit decision. If chargebacks, card declines in emerging markets, or platform holds are recurring pain points, a stablecoin prepaid rail eliminates all three structurally.
Want to offer prepaid USDT subscriptions alongside your card billing? See the integration documentation or create an account to add a chargeback-free recurring option. For processor selection fundamentals, see our cross-border payment platform framework.