DEV Community: 牛云鹏

Three SaaS metrics that never make the dashboard

牛云鹏 — Tue, 20 Oct 2026 04:34:01 +0000

Every SaaS dashboard shows MRR, churn and CAC payback. Three metrics that explain far more about where a business is actually going almost never appear, because each one needs a definition agreed before it means anything: net revenue retention, the Rule of 40, and the magic number.

Here is each one, and the specific way it gets quietly corrupted.

1. Net revenue retention — the denominator is the whole metric

NRR = revenue from the starting cohort today ÷ revenue from the same cohort at period start

Above 100% means the existing base grows without a single new customer. Below 100% means you must win new business just to stand still.

Two variants, and you should report both:

	NRR	GRR
Expansion included	yes	no
Can exceed 100%	yes	no
Answers	is the base compounding?	how much leaks out?

A company at 115% NRR and 82% GRR is growing its base while losing nearly a fifth of it every year. That dependency on continued upsell is invisible if you only quote NRR.

The corruption is almost always the cohort. New customers signed during the period must be excluded from both numerator and denominator. A customer who signed in March and bought more in June is a new logo expanding, not retention.

The other two inflators: a list price rise applied across the base (real revenue, but it does not recur next year), and non-recurring revenue sitting in the starting base — professional services, onboarding fees, usage overage. Compute on recurring revenue only.

Implementation, if you have customer id / plan / MRR per month:

cohort = mrr[mrr.month == t0].query("mrr > 0")
denom  = cohort.mrr.sum()
num    = mrr[(mrr.month == t0 + 12) & mrr.id.isin(cohort.id)].mrr.sum()
nrr    = num / denom

Do this for twelve monthly cohorts and average. A single window picks up whatever renewal cycle happened to land inside it.

2. Rule of 40 — the margin definition is the argument

score = revenue growth rate (%) + profit margin (%)

30% growth with a 10% margin passes. So does 10% growth with a 30% margin. That is the point: it encodes a trade-off rather than demanding both.

The ambiguity is "margin". Free cash flow margin is the original public-company definition and the hardest to flatter. EBITDA margin is the most common. Operating margin is stricter. Whichever you pick, keep it — switching definitions between periods moves the score by more than most operational improvements do.

What the score does not tell you:

It punishes deliberate investment. Hiring a sales team ahead of demand scores badly this year and well next year.
It treats all growth as equal. 25% growth at 110% NRR is a compounding base; 25% at 75% NRR is a treadmill. Same score.
Small numbers distort it. Below roughly $1m ARR the percentages are noise.
It ignores capital efficiency. Growth bought with $3 of equity per $1 of ARR passes the rule and destroys returns.

Use it as one of four signals, alongside NRR/GRR, CAC payback and runway. A company can pass the Rule of 40 and be nine months from insolvency if its cash conversion is poor.

3. Magic number — the lag is doing all the work

magic = (ARR this quarter − ARR last quarter) ÷ S&M spend last quarter

Above 0.75 is considered efficient enough to increase spend. Below 0.5 means acquisition is not paying back fast enough to justify more.

Three details decide whether the number means anything:

Net new ARR includes churn. Using gross new business makes any retention problem disappear — exactly the failure the metric exists to catch.
Full S&M cost. Salaries, commissions, ads, tools, agencies. Excluding salaries inflates it, often by 2x.
The lag. One quarter is convention. If your sales cycle is nine months, one quarter credits revenue to the wrong spend and understates efficiency badly.

What it hides: contract length (a 0.8 looks identical whether you bill monthly or prepay three years), gross margin (it compares ARR to spend, not gross profit to spend), and lifetime entirely. Enterprise at 0.6 with an 8-month payback can be better business than SMB at 0.9 with a 22-month payback.

Use the magic number as the budget dial and CAC payback as the viability floor. When they disagree, the payback is usually right and the magic number is measuring the wrong thing.

The common thread

All three fail the same way: the arithmetic is trivial and the definition is not. NRR needs a cohort rule, the Rule of 40 needs a margin rule, the magic number needs a lag rule. Decide those three once, write them down, and the numbers stop moving between meetings.

Longer write-ups with worked examples and segment benchmarks:

Net revenue retention — NRR vs GRR, cohort rules, the three inflators
The Rule of 40 — which margin, score bands, where it misleads
SaaS magic number — the lag problem, what it hides

I also built free no-signup calculators for churn, runway and CAC payback, each showing its formula and derivation.

Shipping an embeddable calculator: six things I got wrong first

牛云鹏 — Tue, 20 Oct 2026 04:18:23 +0000

I wanted a calculator that a stranger could drop into their blog with one paste. What I ended up learning was mostly about what not to put inside an iframe.

The constraints, in the order they bit me.

1. The widget cannot carry your site chrome

The first version embedded the whole page: header nav, footer, cookie banner, ad slots. On my site that reads as a finished product. Inside someone else's article it reads as a website crammed into a letterbox, and the first thing the host does is delete it.

So the embed route has to render only the tool. In Vue that meant one flag on the route and one v-if in the app shell:

<!-- App.vue -->
<header v-if="!bare">…</header>
<PrivacyBanner v-if="!bare" variant="bar" />
<main>
  <div :class="bare ? 'px-3 py-3' : 'mx-auto max-w-5xl px-4 py-8'">
    <RouterView />
  </div>
</main>
<footer v-if="!bare">…</footer>

const bare = computed(() => route.meta.bare === true)

Two lines of state, a handful of v-ifs. The alternative — a second app entry point — is the kind of duplication that quietly drifts until the embedded version shows last quarter's formula.

2. No ads, and say so

An ad inside your iframe renders on someone else's page. That is their inventory, their layout and their audience. It is also the fastest way to get the embed pulled and the domain remembered badly.

The same applies to analytics in any form that a host would notice. Mine loads a site-wide tag in index.html, which the embed inherits — that one I accepted because it is aggregate pageview counting and nothing about the widget's inputs leaves the browser. Anything more invasive would have to be stripped per-route.

3. `noindex` the embed, canonical it to the real page

Here is the trap: the embed page is a near-duplicate of the tool page. Left indexable, it competes with the page you actually want to rank.

<meta name="robots" content="noindex, follow">
<link rel="canonical" href="https://example.com/tools/ltv-cac-calculator">

follow rather than noindex, nofollow: crawlers should still walk the attribution link back to the real page. And the canonical points at the tool page, not at itself — the embed is a rendering of that page, not a page of its own.

Also: leave the embeds out of the sitemap. If your sitemap is generated from a route table, exclude them explicitly, otherwise you are telling Google "please index these noindex pages" — which it will report as an error for weeks.

4. Size is a suggestion the host will ignore

<iframe width="100%" height="640"> is what I ship, and roughly half of hosts will paste it into a column that is 500px wide. That is fine — the widget is responsive — but it means height cannot be computed from width. A two-column form-plus-result layout that fits at 900px stacks at 500px and gets taller.

Fix: measure it, do not guess. A 20-line script in the embed page posts its height to the parent:

const ro = new ResizeObserver(() => {
  parent.postMessage(
    { type: 'resize', id: 'ltv-cac', height: document.documentElement.scrollHeight },
    '*'
  )
})
ro.observe(document.documentElement)

and the host's one-liner listens. Ship the fixed-height iframe as the default so a host who pastes and walks away still gets something usable, and treat auto-resize as the upgrade.

<script>
addEventListener('message', (e) => {
  if (e.data?.type !== 'resize') return
  const f = document.querySelector(`iframe[data-embed="${e.data.id}"]`)
  if (f) f.style.height = e.data.height + 'px'
})
</script>

5. `loading="lazy"` is not optional

An embed at the top of a long article otherwise blocks that article's first paint for a host who never asked for it. It is one attribute:

<iframe src="…" loading="lazy" style="border:1px solid #e2e8f0;border-radius:12px"></iframe>

6. The attribution link is the entire point

Be honest about the incentive: the reason to build an embed is the link. So put it somewhere a human actually reads, make it small and legible, and do not hide it:

<a href="https://example.com/tools/ltv-cac-calculator" target="_blank" rel="noopener">
  LTV:CAC Ratio Calculator
</a> by Example — free, no signup, nothing stored.

Two things I would not do: target="_top" on that link (it hijacks the host's navigation) and a "powered by" that only appears after 30 days (nobody trusts it, and it gets patched out).

What the whole thing cost

One route per tool, one bare-rendering page, one component that prints the snippet with a copy button. No build step, no script tag, no third-party runtime — which also means nothing to sandbox, no CSP negotiation with the host, and no way for the embed to break their page.

An iframe is the boring answer. For a widget that must never interfere with someone else's site, boring is the feature.

The live version, if you want to see the bare rendering: embed page, and the copy-paste block it belongs to.

Six SaaS metric formulas and the edge cases that break them

牛云鹏 — Tue, 20 Oct 2026 04:12:40 +0000

Every SaaS metric calculator is five lines of arithmetic. The bugs are all in the edges.

I wrote six of them — LTV:CAC, CAC payback, quick ratio, MRR/ARR, churn rate and runway — and wrote the tests before the UI. Below are the cases that return an answer which looks completely reasonable and is completely wrong. They are worth knowing even if you never build a calculator, because the same arithmetic sits inside every spreadsheet that reports these numbers.

1. Zero churn makes LTV infinite

Average customer lifetime is 100 / monthlyChurnPct. At zero churn that is Infinity, so LTV is Infinity, so the LTV:CAC ratio is Infinity.

Nothing throws. The UI renders a number. The number is unbeatable.

const lifetimeMonths = churnPct <= 0 ? null : 100 / churnPct
const ltv = lifetimeMonths === null ? null : arpu * grossMargin * lifetimeMonths

Return null and render "unbounded" with a note that real cohorts always churn eventually. An explicit null beats a helpful default, because a default can be silently summed into a total while null has to be handled.

Same trap on the other side: CAC = 0 makes the ratio infinite. Zero CAC is never true, it means the denominator was not filled in.

2. Annual contracts booked as one month

A $1,200 annual plan is $100 of MRR. Booking the cash when it lands gives you this:

March MRR jumps by $1,200
April MRR falls by $1,100 relative to March
Every chart downstream — net new MRR, growth rate, quick ratio — inherits the spike and the crash

The twelve-fold error is not a rounding problem, it is a definition problem: MRR is a rate, not a receipt. Amortise the contract across its term before it reaches any metric.

const mrr = billingPeriod === 'annual' ? planPrice / 12 : planPrice

3. LTV on revenue instead of gross profit

The 3x rule of thumb assumes gross profit. Using revenue inflates LTV by 1 / grossMargin — at an 80% margin that is 25% too high, at 50% it is double.

// wrong: compares revenue to a cost
const ltv = arpu * lifetimeMonths

// right: compares profit to a cost
const ltv = arpu * grossMargin * lifetimeMonths

This one is nasty because the result still looks like a number. At a 70% margin a business at 2.1x looks like 3.0x, and the conclusion flips from "underinvesting" to "healthy".

4. CAC payback without the margin

const paybackMonths = cac / (arpu * grossMargin)

Drop grossMargin and payback shrinks by the margin: at 80% a real 6.25-month payback reports as 5.0. The rule of thumb is "under 12 months", so a 15-month payback reported as 12 sits exactly on the boundary and passes.

5. Quick ratio when nothing churned

const quickRatio = mrrLost === 0 ? null : mrrGained / mrrLost

A month with no churn is either a tiny base or a data problem. Rendering Infinity makes it indistinguishable from a genuinely excellent month, and it will be copied into a board deck.

6. Money is not a float

0.1 + 0.2 is 0.30000000000000004. It does not matter at these magnitudes until you start summing and comparing — and then paybackMonths <= 12 is false for what a human computes as 12.0.

For a single calculation, round only at the point of display. If you are summing rows, store integer cents.

const round = (n: number, dp = 2) => Math.round(n * 10 ** dp) / 10 ** dp

The general rule

Every one of these is the same bug wearing a different hat: a missing value is not zero, and an unbounded value is not a large one.

A calculator whose inputs are optional and whose outputs are numbers needs a third state. null in the model, an explicit "not enough information" in the UI. The alternative is a dashboard that is confidently wrong, which is worse than one that is visibly empty.

I put these six into free, no-signup calculators — LTV:CAC, CAC payback, quick ratio, MRR & ARR, churn and runway. Every one shows its formula and its derivation, and the edge cases above are covered by tests rather than by hope.