SaaS Metrics for Developers: MRR, Churn, LTV:CAC and Runway, With the Math in Code

Your side project has paying users. Stripe shows a balance, a chart that mostly goes up, and a list of payments. Then someone asks for your MRR, your churn or your LTV:CAC, and the dashboard doesn't quite answer.

Most of these metrics are a line or two of arithmetic. What makes them confusing is the definitions: what counts as recurring, which churn, revenue or profit. Get those wrong and the numbers look healthier than the business is.

We explain each one in the StartupReader learn section and built free calculators for them. This post puts them in one place for developers, each as a few lines of JavaScript you can paste into a console and run against your own numbers.

The examples use round, made-up numbers for a small subscription product. The benchmarks quoted are rules of thumb, not standards.

TL;DR

Metric	Formula	Tells you
MRR / ARR	Recurring fees normalised to a month; ARR = MRR × 12	How big the subscription business is right now
Net new MRR	New + expansion − contraction − churned	Where growth comes from and where it leaks
Churn	Customers lost ÷ customers at the start	How fast the bucket empties
LTV:CAC	Lifetime gross profit ÷ cost to win a customer	Whether each customer makes money
CAC payback	CAC ÷ monthly gross profit per customer	How long before a customer repays their cost
Runway	Months until cash runs out at the current burn	How long you have to fix the rest
Burn multiple	Net burn ÷ net new ARR	How much cash each unit of growth costs

1. MRR: normalise everything to a month

MRR (monthly recurring revenue) is what your current customers pay you every month on subscriptions. The rule that trips people up: normalise every plan to a monthly amount, and leave out anything that isn't recurring.

const subs = [
  { plan: "monthly", price: 29 },
  { plan: "monthly", price: 29 },
  { plan: "annual", price: 290 },                // billed once a year
  { plan: "monthly", price: 99, setupFee: 500 }, // the setup fee isn't recurring
];

const monthly = (s) => (s.plan === "annual" ? s.price / 12 : s.price);
const mrr = subs.reduce((sum, s) => sum + monthly(s), 0); // 181.17
const arr = mrr * 12;                                     // 2174

The annual customer adds $24.17 to MRR every month, not $290 in the month they pay. The $500 setup fee is revenue, but not recurring revenue. Also leave out free trials, unpaid pilots, one-off services, and VAT, GST or sales tax you collect. Count what customers actually pay after discounts. Usage-based fees are a judgement call: many companies count a committed minimum and report the rest separately. Whatever you choose, say so. More in ARR vs MRR.

2. Net new MRR: the bridge

A single MRR number hides what's happening underneath. Split each month's change into four parts:

function mrrBridge({ start, newMrr, expansion, contraction, churned }) {
  const netNew = newMrr + expansion - contraction - churned;
  return {
    end: start + netNew,
    netNew,
    growthPct: (netNew / start) * 100,
    // Revenue kept from customers you already had, upgrades included
    nrrPct: ((start + expansion - contraction - churned) / start) * 100,
  };
}

mrrBridge({ start: 10_000, newMrr: 1_200, expansion: 400, contraction: 150, churned: 350 });
// { end: 11100, netNew: 1100, growthPct: 11, nrrPct: 99 }

11% growth in a month looks great. The last line is the one to watch: existing customers are paying 99% of what they paid last month, so all the growth is coming from new sign-ups. That's net revenue retention (NRR). Investors usually quote it over 12 months: what customers who were paying a year ago pay today, divided by what they paid then. Above 100% means your existing customers grow on their own, through upgrades and extra seats, even before you win anyone new. See the glossary entry.

3. Churn compounds

Churn is the share of customers who leave in a period. Two things to get right: it compounds, and customer churn isn't revenue churn.

function churn({ customersStart, customersLost }) {
  const monthly = customersLost / customersStart;
  return {
    monthlyPct: monthly * 100,
    annualPct: (1 - (1 - monthly) ** 12) * 100, // compounded, not monthly × 12
    lifetimeMonths: 1 / monthly,                // average customer lifetime
  };
}

churn({ customersStart: 400, customersLost: 12 });
// { monthlyPct: 3, annualPct: 30.6, lifetimeMonths: 33.3 }

3% a month sounds small. Over a year it's 30.6% of your customers, and the average customer stays about 33 months. (2% a month is about 21.5% a year, not 24%: each month's churn applies to a slightly smaller base.)

Revenue churn is MRR lost ÷ MRR at the start. In the bridge above, $350 of $10,000 churned, so revenue churn was 3.5%. If the customers who leave are mostly on your cheapest plan, revenue churn will be lower than customer churn. If they're your biggest accounts, it'll be higher. Track both. The churn rate calculator does the conversions.

4. LTV, CAC and payback: does each customer make money?

CAC (customer acquisition cost) is everything you spent on sales and marketing in a period, divided by the customers you won in it. LTV (lifetime value) is the gross profit a customer brings in before they leave. Note gross profit, not revenue:

function unitEconomics({ arpa, grossMargin, monthlyChurn, spend, newCustomers }) {
  const cac = spend / newCustomers;
  const monthlyGrossProfit = arpa * grossMargin; // arpa = average revenue per account
  const ltv = monthlyGrossProfit / monthlyChurn;
  return { cac, ltv, ratio: ltv / cac, paybackMonths: cac / monthlyGrossProfit };
}

unitEconomics({ arpa: 50, grossMargin: 0.8, monthlyChurn: 0.03, spend: 12_000, newCustomers: 30 });
// { cac: 400, ltv: 1333, ratio: 3.3, paybackMonths: 10 }

A common rule of thumb for subscription businesses is an LTV:CAC of at least 3:1, with CAC paid back within about 12 to 18 months. This example clears both.

Gross margin is where developers have the most control, and the most to lose. Hosting, third-party APIs, payment fees and support all come out of it. If your product calls an LLM on every request, that's a cost of serving the customer, not an overhead. Here's the same product with gross margin down to 65%:

unitEconomics({ arpa: 50, grossMargin: 0.65, monthlyChurn: 0.03, spend: 12_000, newCustomers: 30 });
// { cac: 400, ltv: 1083, ratio: 2.7, paybackMonths: 12.3 }

Same price, same churn, same marketing, and the ratio drops below 3. Choosing a smaller model, caching responses, or putting usage limits on the free plan are unit-economics decisions as much as engineering ones. The unit economics explainer covers cohorts and the usual mistakes, and the LTV:CAC calculator runs these numbers.

5. Burn and runway

Net burn is how much cash you lose in a month: expenses minus revenue, leaving out any money raised. Runway is how many months until the cash runs out. The simple version is cash ÷ net burn. A month-by-month loop is barely longer and shows what growth does to it:

function runway({ cash, revenue, expenses, revenueGrowth = 0, expenseGrowth = 0 }) {
  let balance = cash;
  for (let month = 1; month <= 120; month++) {
    const burn = expenses - revenue;
    if (burn > 0 && balance < burn) return month - 1 + balance / burn;
    balance -= burn;
    revenue *= 1 + revenueGrowth;
    expenses *= 1 + expenseGrowth;
  }
  return Infinity; // the cash never runs out
}

const company = { cash: 300_000, revenue: 11_100, expenses: 36_000 };
runway(company);                                             // 12.0 months
runway({ ...company, revenueGrowth: 0.05 });                 // 15.0 months
runway({ ...company, revenueGrowth: 0.07 });                 // Infinity
runway({ ...company, revenueGrowth: 0.08, expenseGrowth: 0.03 }); // 12.0 months

On flat revenue, $300K lasts a year. Growing revenue 5% a month buys three more months. At 7% a month, revenue catches up with expenses before the money runs out, and the company never needs to raise again. Founders call that "default alive". Then hire: expenses growing 3% a month take runway back to 12 months, even with revenue growing faster. Run your own numbers in the burn rate and runway calculator.

6. Burn multiple and the Rule of 40

Two ratios come up once a company is raising money or scaling. The burn multiple asks how much cash the whole company burned to add each dollar of new ARR:

const burnMultiple = (netBurn, netNewArr) => netBurn / netNewArr;

// One quarter: $24,900 burned a month, $1,100 of net new MRR a month
burnMultiple(3 * 24_900, 3 * 1_100 * 12); // 1.89

That's about $1.89 burned for each $1 of ARR added. Under the widely repeated bands popularised by investor David Sacks, 1.5x to 2x is "good", under 1x "amazing" and over 3x "bad". On a small ARR base, a single deal can swing it, so watch the trend over several quarters. More in the burn multiple explainer.

The Rule of 40 is for later-stage software companies: revenue growth rate plus profit margin should reach 40%.

const ruleOf40 = (growthPct, marginPct) => growthPct + marginPct;

ruleOf40(70, -25); // 45: growing fast while losing money, still passes
ruleOf40(50, -20); // 30: falls short

It's less useful early on, when growth from a small base swings wildly. The Rule of 40 explainer covers which margin to use.

Mistakes that flatter the numbers

• Booking annual plans as MRR in the month they're paid. You get one huge month, then eleven small ones.
• Counting trials, setup fees or services as recurring revenue.
• Using revenue instead of gross profit in LTV. It overstates what a customer is worth.
• Leaving salaries, tools and agency fees out of CAC. Paid ads are only part of the cost of winning customers.
• Extrapolating churn from three good months. Early customers are often your biggest fans, so newer ones may leave faster.
• Blending everything into one average. Group customers by the month they joined (cohorts) and compare. If newer cohorts churn faster, averages hide it until it's too late.

A monthly checklist

Once a month, from your billing data and bank balance:

1. MRR, split into new, expansion, contraction and churned.
2. Customer and revenue churn, and NRR once you have a year of data.
3. CAC, LTV:CAC and payback, ideally per acquisition channel.
4. Gross margin, especially if usage drives your infrastructure or API bill.
5. Net burn and runway, flat and with your realistic growth rate.

That fits in a short script you can run against a Stripe export. Or use the free calculators for ARR and MRR, churn, LTV:CAC, runway and break-even, all at startupreader.com/tools.

Disclosure: I'm part of the StartupReader team. This post was drafted with AI assistance, and every formula and figure was checked against the linked explainers and by running the code above.