Fast. Simple. No meetings. No delays.
Home / Blog / Tel Aviv / Setting Up Subscription Billing for an Early-Stage SaaS

Setting Up Subscription Billing for an Early-Stage SaaS

The moving parts of subscription billing — plans, trials, upgrades, failed payments and invoices — and how to keep the first version simple.

Cover graphic for the article: Setting Up Subscription Billing for an Early-Stage SaaS

For an early-stage product, SaaS subscription billing setup means choosing a few simple plans, letting a billing provider handle cards and invoices, and treating the provider's webhooks as the source of truth for who has paid. Keep the first version small, and add upgrades, coupons and usage pricing only when customers actually ask.

Plans, trials and what to charge for

Billing code is expensive to change once customers are on it, but pricing decisions are cheap to change early. Decide the commercial model before you open the provider dashboard.

  • Start with few plans. Two or three tiers are easier to explain, support and test than a long matrix. A free or trial tier plus one paid plan is a legitimate first version.
  • Charge for something customers value and you can measure. Seats, projects, volume or access to features are common. Pick one main axis; combining several multiplies the edge cases.
  • Decide how trials work. Do you ask for a card up front or not? What happens when the trial ends: read-only access, a downgrade or a lockout? Write the rule down before coding it.
  • Monthly first. Annual plans bring cash up front but add questions about refunds and mid-term changes. Add them once the basics are stable.

This is a planning-level view. If you are scoping the whole product, see our guide on what to build first in an MVP, and for the engineering detail read implementing subscription billing.

SaaS subscription billing setup: choosing a provider

Few startups should build billing from scratch. Cards, 3-D Secure, receipts, retries and tax handling are large areas, and the provider carries much of the compliance burden by keeping card numbers off your servers.

QuestionWhy it matters
Does it support subscriptions natively?Plans, trials, proration and retries should be features, not code you write.
Which countries, currencies and payment methods does it cover?Your customers' location decides what you can accept. Check the provider's documentation for your market.
Who is the seller of record?Some providers act as the merchant of record and handle sales tax or VAT collection; others leave that to you. Understand which model you are buying.
Is there a hosted checkout and customer portal?These save weeks of interface work and reduce your security scope.
How good are the webhooks and test mode?You will rely on both daily while building.
What does leaving cost?Ask how you can export customer and payment-method data if you switch later.

Verify every capability in the provider's own documentation rather than relying on summaries, including this one. Features and regional availability change.

Webhooks and the source of truth

A billing webhook is an HTTP request the provider sends to your server when something happens: a payment succeeded, a subscription changed, a card failed. It is the reliable way to learn what occurred, because the customer might close the browser before your success page loads.

Build around these rules:

  1. Store the provider's customer and subscription identifiers in your database, linked to your own account record.
  2. Update access based on webhook events, not on the redirect after checkout.
  3. Verify each webhook's signature so nobody can forge a payment.
  4. Make handlers idempotent. Providers may deliver the same event more than once or out of order, so processing it twice must be harmless.
  5. Log every event received, so you can replay or investigate when something looks wrong.

Keep a simple internal status such as trialing, active, past due or cancelled, and map provider states into it in one place. Then the rest of your product asks one question: does this account have access?

Failed payments and dunning

Cards expire, funds run short and banks decline. Handling this is called dunning, and it quietly decides how much recurring revenue you keep.

  • Use the provider's automatic retry schedule first; do not write your own on day one.
  • Email the customer when a payment fails, with a direct link to update their card. Many providers can send these emails, but check the wording is yours and not confusing.
  • Decide on a grace period during which the account still works, and what happens when it ends.
  • Show an in-app notice to account owners while the payment is overdue.
  • Make reactivation easy: when the card is fixed, access should return without a support ticket.

Upgrades, downgrades and proration

Proration means charging or crediting the difference when a customer changes plan part-way through a billing period. Providers can calculate it, but you must still choose the policy.

  • Upgrades usually take effect immediately, with a charge for the remaining period.
  • Downgrades are often easier to apply at the end of the current period, which avoids credits and refunds.
  • Cancellations should say clearly whether access continues until the period ends.
  • If limits differ by plan, define what happens when a customer downgrades while exceeding the lower plan's limits.

Support the simplest policy that is fair and explain it on the pricing page. You can refine it when real customers show you the awkward cases.

Invoices and tax records

Business customers will ask for invoices, and your accountant will need clean records. Choose a provider that generates numbered invoices or receipts with the details your customers need, and make them available in a billing page or by email.

Tax treatment of software subscriptions varies by country and by customer type, and it changes. Do not guess. Ask a qualified accountant what you must collect, report and display, and check how your chosen provider supports it. Keep payment and invoice data exportable for them.

Testing billing end to end

Use the provider's test mode and make a written script covering every path.

  1. Sign up, start a trial, and let it expire.
  2. Pay with a successful card, then with one that is declined, then one that needs extra authentication.
  3. Upgrade, downgrade and cancel, and check access at each step.
  4. Simulate a failed renewal and confirm emails, grace period and recovery.
  5. Replay a webhook twice and send one out of order.
  6. Check that your admin view and the provider dashboard agree.

Repeat the script whenever you change plans or billing logic.

Putting it together

Start with the smallest model you can explain on one page, hand the heavy lifting to a provider, and let webhooks decide access. Our guide to building a SaaS product places billing in the wider roadmap, and the Tel Aviv software development page explains how we approach early-stage builds.

Frequently asked questions

Should I build billing myself?

Almost never at the start. Payment security, retries, invoices and tax handling are large areas, and a provider covers much of that for you. Build only the thin layer that connects the provider to your accounts and access rules, and revisit the decision if your needs become unusual.

How are failed payments handled?

The billing provider retries the charge on a schedule and sends events to your server. You email the customer with a link to update their card, keep access during a grace period, then restrict or cancel the account if payment still fails. Fixing the card should restore access automatically.

What is a billing webhook?

It is an automated message your billing provider sends to a URL on your server when something changes, such as a successful payment or a cancelled subscription. Your system verifies the signature, records the event and updates the account, so access stays correct even if the customer never returns to your site.

Related articles

🚀 Start Now