SaaS business model: what it is and how it works

A SaaS business sells access to software over the internet for a recurring fee while the vendor hosts, maintains, and updates the app. Customers typically pay monthly or annually, and the software is delivered via cloud infrastructure—often in a multi‑tenant architecture where many customers share the same codebase securely. That’s the model in a sentence. (TechTarget, IBM, AWS SaaS whitepaper).

Key takeaways

• SaaS = subscription access to hosted software; the vendor runs the app and ships continuous updates. (TechTarget).
• Core money flows: per‑seat subscriptions, usage‑based metering, or hybrids; subscription revenue is usually recognized ratably over the contract term under ASC 606. (Atlassian 10‑K excerpt, Datadog 10‑K excerpt).
• What to measure: ARR/MRR, churn and retention, CAC, payback, LTV, and Rule of 40. (Bessemer cloud metrics, ChartMogul cheat sheet, Rule of 40).
• Typical pricing patterns: per‑user seats (e.g., Atlassian Cloud) and pay‑as‑you‑go metering (e.g., Twilio), often blended. (Atlassian licensing, Twilio pricing overview).
• Benchmarks are directional: strong SaaS gross margins are often 70–80%+, with higher or lower figures depending on services and infra mix. (Stripe on SaaS margins).

What “Software as a Service” actually is

• Delivery: Software runs in the provider’s cloud and is accessed via browser or API. Users don’t install servers or manage upgrades; the vendor ships frequent updates. (TechTarget).
• Architecture: Many SaaS products are multi‑tenant (one codebase serves many customers with strict data isolation), though single‑tenant and hybrid patterns exist. (IBM, Harvard EA note).
• Why it matters: Multi‑tenancy lets vendors scale faster and operate at lower unit costs; customers get lower upfront spend and immediate access. (TechTarget).

How a SaaS business makes money

SaaS monetization typically follows three patterns—often combined on one pricing page.

1. Per‑seat (per‑user) subscriptions

• Customers pay per active user per month or year (common for collaboration and productivity tools). Atlassian explicitly uses progressive per‑user pricing in Cloud. (Atlassian Cloud licensing).

2. Usage‑based (metered) pricing

• Bill customers for consumption units (messages, API calls, data scanned) with on‑demand or committed tiers. Twilio charges per message/minute/number and also sells subscription‑based software like Segment and Flex—an archetypal hybrid. (Twilio pricing overview, Twilio investor materials).
• Trend: “Three in five” SaaS companies report some form of usage‑based pricing according to OpenView’s State of Usage‑Based Pricing (via Chargebee’s synthesis). (Chargebee/OpenView summary).

3. Freemium and free trials

• Offer a free tier or time‑bounded trial to drive product‑led acquisition; convert via in‑product paywalls and usage caps. (HBR on freemium, OpenView on PLG).

Payment rails and billing

• Payment processing: Stripe’s headline US card pricing is 2.9% + $0.30 per successful online transaction (custom pricing available), with additional fees for international cards and currency conversion. (Stripe pricing page).
• Subscription management: tools like Stripe Billing, Chargebee, and Paddle handle invoicing, proration, coupons, tax, dunning, and revenue operations. (Stripe Billing features, Chargebee pricing/features, Paddle pricing model).

Revenue recognition (how revenue hits your P&L)

• Under ASC 606/IFRS 15, subscription services are generally recognized ratably over the contract term once access is provided; usage overages are recognized as incurred. Public SaaS filings disclose this explicitly. (Example 10‑K language, Datadog 10‑K, PTC 10‑K).

The five building blocks of SaaS economics (with formulas you can copy)

Track these from day one; investors will ask for them in exactly these words.

1. Recurring revenue

• MRR: sum of normalized monthly subscription revenue. ARR = 12 × MRR. (Bessemer, ChartMogul metrics guide).

2. Churn and retention

• Logo churn (customer count): customers lost ÷ customers at period start.
• Revenue churn (MRR): churned MRR ÷ starting MRR.
• Net revenue retention (NRR): (Starting MRR + expansion − contraction − churn) ÷ Starting MRR. (ChartMogul help).

3. CAC and payback

• CAC: sum of sales/marketing to acquire a cohort ÷ new customers in that cohort. CAC payback (months) ≈ CAC ÷ monthly gross profit per customer. (Bessemer).

4. LTV

• Simplified subscription LTV ≈ (ARPA × gross margin %) ÷ churn rate. Use revenue churn for revenue LTV; use logo churn for customer LTV. Sanity‑check with sensitivity analysis. (ChartMogul cheat sheet).

5. Rule of 40 (portfolio‑level health)

• Rule of 40 = revenue growth rate + profit margin; healthy SaaS often clears 40%. Nuance: the “margin” input (EBITDA vs FCF) varies by source. (Rule of 40 overview).

Worked micro‑example (plug your numbers)

• Assume: $50 ARPA/month, 80% gross margin, 2% monthly revenue churn, $300 CAC.
• LTV ≈ ($50 × 0.80) ÷ 0.02 = $2,000.
• CAC payback ≈ $300 ÷ ($50 × 0.80) = 7.5 months.
• Interpretation: LTV:CAC ≈ 6.7× and payback < 12 months—attractive for most seed‑stage investors (verify with your own funnel). (Bessemer, ChartMogul).

Pricing models that actually ship

Use at least one simple plan customers grok in 10 seconds.

• Per‑seat tiers: Starter/Pro/Business with user caps and feature gates. Atlassian’s Cloud model is a live example of progressive per‑user pricing by product and app. (Atlassian Cloud licensing).
• Usage ladders: PAYG with volume discounts and committed‑use contracts (e.g., Twilio bills per message/minute/number, and offers subscriptions for Segment/Flex). (Twilio pricing overview, Twilio SMS pricing page).
• Hybrid: Base subscription + metered overages (common in infra/API, storage, AI tokens). OpenView’s research shows usage‑based elements are now widespread; consider enabling both for flexibility. (Chargebee/OpenView).

Template: one‑page pricing draft you can copy

• Row 1: Three columns — Free, Pro, Business.
• Row 2 (headline): “Free forever,” “Most teams,” “Advanced security & support.”
• Row 3 (price): $0; $20/user/mo billed annually; Contact sales.
• Rows 4–7 (value): core features; seat limits; usage caps; support SLA.
• Footer: “Need usage‑based? Start Pro and add overages at $X per 1,000 events.”
• Fine print: “Annual subscriptions recognized over term; cancel anytime at renewal.”

The unsexy systems that make SaaS work

• Billing and payments: start with Stripe (cards, ACH, invoicing) or Paddle (merchant‑of‑record) if you want offloaded tax/compliance; use Chargebee if you need advanced catalogs, complex entitlements, or multi‑frequency billing. (Stripe pricing, Paddle pricing model, Chargebee features).
• Dunning and failed payments: enable Stripe Smart Retries or Chargebee Smart Dunning on day one; configure retry windows shorter than your billing period and send card‑update links. (Stripe dunning overview, Stripe Billing features, Chargebee Smart Dunning).
• Metrics: connect billing to ChartMogul or Baremetrics to compute MRR, churn, and NRR correctly. Baremetrics’ public pricing shows affordable tiers for small ARR. (ChartMogul pricing page, Baremetrics pricing).
• SLAs and reliability: publish availability targets (99.9% premium/99.95% enterprise is a common pattern) and tie them to service credits. Atlassian’s public SLAs are a useful model. (Atlassian SLA, AWS on SLAs).

Put your early SaaS on a single, credible link: founders.page

For an early SaaS, people buy the founder as much as the product. Create a concise public hub that answers: who you are, what you’ve shipped, and how to talk to you.

• What to include on your founders.page: your main product and any prior tools; a short “What it does in one sentence”; a Loom demo; links to docs, pricing, and your GitHub; milestones like “beta opens,” “first 10 customers,” or “$1k MRR”; and a “Book a call” link for design partners and enterprise buyers.
• Why it helps your SaaS: you’ll have one link to put in cold emails, directory profiles, and your pricing page footer; prospects can see your track record and book a call without back‑and‑forth.
• Set it up now: create your free founders.page.

SaaS vs perpetual license vs open‑core (quick comparison)

Dimension	SaaS subscription	Perpetual license	Open‑core SaaS
How customers pay	Recurring subscription; sometimes with usage overages	One‑time license + optional maintenance	Free core; paid proprietary features or hosted service
Delivery	Hosted by vendor; browser/API	Customer hosts on their systems	Hosted SaaS or self‑host + paid add‑ons
Revenue recognition	Ratable over service term	Often upfront on delivery of license	Depends: SaaS parts ratable; license parts upfront
Pros for customer	Lower upfront cost; no maintenance	Full control, can run offline	No lock‑in to basics; can self‑host
Pros for vendor	Recurring revenue; continuous updates	Large upfront cash	Community adoption + monetization path
Sources	TechTarget	TechTarget (perpetual license)	Open‑core model

(Perpetual vs subscription trade‑offs are also summarized by Cisco/Revenera. Cisco explainer, Revenera glossary.)

A 30‑day plan to test whether your problem fits SaaS

• Day 1–3: Define one job‑to‑be‑done and the smallest useful workflow you can automate. Decide seats vs usage (or both) by mapping your value metric to outcomes. (OpenView PLG intro).
• Day 4–7: Stand up billing (Stripe + Billing, or Paddle). Create one pay‑monthly and one annual plan; enable Smart Retries/dunning. (Stripe pricing, Stripe dunning).
• Day 8–10: Ship a minimum UI and a single “aha” moment. Gate features that map to clear plan differences.
• Day 11–14: Publish a pricing page using the template above. Add your SLA headline and support response time promise (even if it’s “next business day”). (Atlassian SLA pattern).
• Day 15–20: Recruit 10–20 design partners. Put the link on your founders.page and in relevant founder directories. (Best founder directories of 2026).
• Day 21–30: Instrument your funnel and metrics. Pipe billing into ChartMogul or Baremetrics and read off MRR, churn, and early NRR. (ChartMogul, Baremetrics pricing).

Common pitfalls (and how to avoid them)

• Counting cash as revenue: if you take annual prepay, you’ll bank the cash but recognize revenue monthly—plan your runway accordingly. (See disclosures in public SaaS 10‑Ks on ratable recognition.) (Example 10‑K language, PTC 10‑K).
• Under‑instrumented churn: track both logo churn and revenue churn; one can improve while the other worsens. (ChartMogul help).
• Ignoring failed payment churn: enable automated retries and dunning; set explicit end‑states for non‑recovered invoices. (Stripe dunning guide, Chargebee Smart Dunning).
• Hand‑wavy pricing: choose a value metric customers understand (users, projects, events). Iterating price is easier than fixing a broken value metric. (Chargebee pricing guide).
• Starving support: poor onboarding/support shows up as churn in three months; publish a minimal SLA and meet it. (Atlassian SLA reference).

Benchmarks and financial shape

• Gross margin: SaaS businesses often operate at 70–80%+ gross margin on software revenue; hybrids with heavy services run lower. Treat any single benchmark as directional—your COGS mix matters. (Stripe explainer).
• Product‑led growth: many modern SaaS companies rely on PLG (free/try → expand), coined and popularized by OpenView; it’s a GTM strategy, not a religion—pair with sales where needed. (OpenView on PLG).
• Cash flow trough: subscription revenue is smooth, but cash can lag when you invest ahead of collections; Skok’s classic “SaaS cash flow trough” describes the effect. (ForEntrepreneurs).

Quick glossary (with canonical definitions)

• SaaS: subscription access to software hosted by provider. (TechTarget).
• Multi‑tenancy: one codebase/infra securely serves many customers. (IBM).
• ARR/MRR: normalized recurring revenue measures. (Bessemer).
• NRR: retention including expansion/downgrade/churn effects. (ChartMogul help).
• Rule of 40: growth rate + profit margin ≈ 40% signal. (Rule of 40).

Where to go next

• If you plan to fund from revenue, read our practical playbook: Bootstrapping SaaS to Millions: the 0–$3M ARR playbook.
• Want a deeper build checklist? See: How to build a bootstrapped B2B SaaS company.

Copy‑paste templates

1. “What we sell” one‑liner

• “We help [role] at [customer type] [achieve outcome] by [how your app works]—priced [per seat/usage] with [SLA/support].”

2. Minimal cancellation survey (to cut avoidable churn)

• “What problem were you hoping our product would solve?” (free text)
• “Which best describes your reason for canceling?” Price | Missing feature | Switching tools | No longer needed | Poor onboarding | Other.
• “What would bring you back?” (free text)

3. First three metrics to put on your dashboard

• New MRR, Churned MRR, Expansion MRR (with notes on the event that caused each change). (ChartMogul metrics guide).

4. Dunning settings (starter defaults)

• Retries: 6–8 attempts over ≤ billing period length (e.g., 10–14 days for monthly).
• Emails: immediate, day 3, day 7 with a secure card‑update link.
• After last retry: cancel or downgrade access; tag account “payment‑at‑risk.” (Stripe dunning, Chargebee Smart Dunning).

5. Simple unit‑economics scratchpad

• Inputs: ARPA, gross margin %, monthly churn %, CAC.
• Outputs: LTV = (ARPA × margin)/churn; Payback = CAC/(ARPA × margin); LTV:CAC = LTV/CAC. (Bessemer, ChartMogul).