Your Company Has a Pulse. You're Probably Not Measuring It.

How auto-scoring KPI health ranges tell a founder exactly what needs attention — without opening a spreadsheet

Technique · Next AI Labs · Human-Agent Research · 11 min read

Most companies have dashboards. Good ones, even. Stripe gives you MRR. Facebook gives you CPC. Google Analytics gives you sessions.

But dashboards show you numbers. They don't tell you what's wrong.

A founder opens Stripe and sees CAC at $112. Is that good? It depends on their LTV. It depends on their stage. It depends on what it was last week. The number alone is meaningless without context — and that context lives in the founder's head, not in the dashboard.

This is the gap we kept falling into. Not a lack of data. A lack of interpreted data. The metrics existed across five different services. What didn't exist was a system that could look at all of them simultaneously and say: "Three things are healthy. Two need attention. One is critical."

We built that system. It watches nine core KPIs, auto-calculates derived metrics, scores each one against pre-defined health ranges, and surfaces a single color-coded view that a founder can read in under ten seconds. No spreadsheets. No mental arithmetic. No "let me check Stripe and get back to you."

This article describes the architecture — not as a product pitch, but as a transferable pattern. Any team with a subscription business and basic data access can build this in a week.

The Problem: Data Overload Disguised as Visibility

The standard advice for SaaS founders is "know your metrics." So they build dashboards. They connect Stripe. They export CSVs. They create Notion tables with formulas.

And then something subtle happens: they stop looking.

Not because they don't care. Because the dashboard requires effort to interpret. You have to remember that MRR churn below 5% is excellent but below 8% is still fine. You have to calculate CAC manually by dividing total spend by new subscribers. You have to compare this week's numbers to last week's numbers — which means finding last week's numbers first.

baseline drift is what happens next. Metrics gradually move away from healthy ranges, but nobody notices because nobody is doing the comparison. By the time the founder checks, the 3% drift has become a 15% problem.

The irony is stark: the companies that need real-time health visibility the most — early-stage startups where every dollar matters — are the ones least likely to have a data analyst building it for them.

Attempt 1: Just Use Stripe

Stripe's dashboard is genuinely good. MRR, net volume, subscriber growth — it's all there. For a while, this was the system.

But Stripe doesn't know your ad spend. It can't calculate CAC because it doesn't know how much you paid Facebook to acquire those subscribers. It can't compute LTV/CAC ratio because it doesn't have the denominator.

And critically, Stripe shows you numbers without judgment. MRR churn of 12% is displayed the same way as MRR churn of 4% — as a number. The color-coding, if any, is generic (red for down, green for up). But "down" isn't always bad. If your CAC dropped 20%, that's excellent. If your churn dropped 20%, also excellent. If your MRR dropped 20%, that's a fire.

Whether "up" is good or "down" is good depends on the metric. Stripe doesn't encode that knowledge. Your spreadsheet doesn't either. That knowledge lives in the founder's head — the worst possible place for it.

Attempt 2: Build a Comprehensive Dashboard

The next iteration was a custom dashboard that pulled data from all five sources — Stripe, Facebook Ads, the user database, analytics, and the billing system — and displayed everything in one place.

This was better and worse simultaneously.

Better because the data was unified. Derived metrics like CAC (total spend divided by new subscribers) and LTV/CAC ratio could be computed automatically. Collection efficiency (actual revenue divided by expected revenue) became visible for the first time.

Worse because it was 30+ rows of numbers. A wall of data that took five minutes to read. The founder's eyes would glaze over by row eight. The dashboard had all the answers but didn't know which questions mattered right now.

Attempt 3: Health Scoring — The System That Knows What "Good" Means

The breakthrough was simple in retrospect: encode the definition of "healthy" as configuration, not as tribal knowledge.

For each core KPI, we defined explicit health ranges — six to eight tiers, from "Excellent" down to "Critical." Each tier has a numeric boundary, a human-readable label, and a color. The system doesn't just show you a number. It shows you a number with a verdict.

Here's what this looks like in practice for Customer Acquisition Cost:

CAC Health Tiers:
─────────────────────────────────────
  < $32        Silver Grail  (animated)
  $32 - $50    Outstanding
  $50 - $75    Excellent
  $76 - $100   Healthy
  $101 - $125  Acceptable
  $126 - $175  Weak
  $176 - $250  Poor
  > $250       Critical
─────────────────────────────────────

Nine KPIs. Each with its own tier structure. Each with a target value. Each with a direction flag that tells the system whether higher is better (LTV, conversion rate) or lower is better (CAC, churn rate).

The "Silver Grail" tier for CAC deserves special mention. It's the range that, if you hit it, means your unit economics are so favorable that the business essentially prints money. The UI literally pulses with a golden glow when CAC drops below $32. It's the one metric tier that celebrates rather than just reports.

Direction-Aware Evaluation

This is the detail that separates health scoring from a simple color-coded spreadsheet. The system encodes directionality for every metric:

• Higher is better: LTV, Trial Conversion Rate, ARPU, Collection Efficiency
• Lower is better: CAC, Cost Per Click, MRR Churn Rate
• Neutral: Ad spend, subscriber counts (these are decisions, not outcomes)

When the system calculates the change between your baseline and your live data, it doesn't just say "+15%" in green. It evaluates whether +15% is good or bad for that specific metric. A 15% increase in churn shows red. A 15% increase in conversion shows green. A 15% increase in ad spend shows gray — neutral, because spend is a deliberate choice, not a health signal.

This sounds obvious to a human who knows the business. But it's the kind of contextual knowledge that vanishes when the founder delegates to a dashboard tool or hands the metrics to a new hire.

The Architecture: Five Sources, One View, Zero Effort

The system pulls from five data sources on a rolling basis:

┌──────────────────────────────────────────┐
│           Real-Time Health View          │
│         (auto-refreshes every 5 min)     │
└────────────────────┬─────────────────────┘
                     │
     ┌───────────────┼────────────────┐
     │               │                │
 ┌───▼────┐   ┌──────▼─────┐   ┌─────▼──────┐
 │ Stripe │   │  User DB   │   │ Analytics  │
 │ MRR,   │   │  Funnel    │   │ Sessions,  │
 │ churn, │   │  stages,   │   │ retention, │
 │ ARPU   │   │  at-risk   │   │ active     │
 └────────┘   └────────────┘   │ users      │
                               └────────────┘
     ┌─────────┐         ┌──────────────┐
     │ Ad      │         │ Billing      │
     │ Platform│         │ Invoice      │
     │ CPC,    │         │ success,     │
     │ spend   │         │ recovery     │
     └─────────┘         └──────────────┘

The key constraint: zero touch observability. The founder opens one page. Everything is already there. No date pickers, no query builders, no export-to-Excel. The system shows a rolling 7-day window by default, compared against whatever historical baseline the founder selects.

The comparison happens across every metric simultaneously:

| Metric | Baseline | Live | Change | Health | |--------|----------|------|--------|--------| | CAC | $94 | $87 | -$7 (-7.4%) | Healthy | | MRR Churn | 6.2% | 8.4% | +2.2 (+35.5%) | Acceptable | | LTV/CAC | 2.8x | 3.1x | +0.3 (+10.7%) | Excellent | | Trial Conv. | 18% | 22% | +4.0 (+22.2%) | Healthy |

The founder's eye goes straight to the red. MRR churn jumped 35% — that's a critical alert. Everything else is green or improving. In three seconds, they know exactly where to focus.

Critical Change Alerts

The system doesn't wait for the founder to scan the table. It computes which metrics have degraded beyond a threshold — 15% triggers a warning, 20% triggers a critical alert — and surfaces them as a banner at the top of the view.

This is the equivalent of a vital signs monitor beeping when blood pressure spikes. The founder might not have opened the dashboard today. But when they do, the critical alert is the first thing they see.

The Metrics That Matter: What We Chose and Why

After iterating through dozens of metrics, we converged on nine core KPIs that, together, provide a complete picture of subscription business health:

Acquisition Efficiency

1. Cost Per Click — Are we paying a reasonable price for attention?
2. CAC — What does it actually cost to acquire a paying subscriber?

Revenue Quality

1. Subscriber LTV — How much is a subscriber worth over their lifetime?
2. ARPU — How much revenue does each subscriber generate monthly?
3. LTV/CAC Ratio — Are we spending sensibly relative to what we earn back?

Retention Health

1. Trial Conversion Rate — Are trials turning into paying customers?
2. MRR Churn Rate — Are we losing revenue to cancellations?

Operational Fitness

1. Collection Efficiency — Are we actually collecting the revenue we're owed?
2. Income Recirculation Rate — How much of our revenue is being reinvested?

The number nine is not arbitrary. It's the result of removing everything that didn't change decisions. We started with 30+ metrics. Most of them were interesting but not actionable. "Active Users (7 day)" tells you something, but it rarely tells you to do something different. CAC going critical tells you to either fix your funnel or cut your ad spend. That's the difference between a metric and a KPI.

The non-KPI metrics still exist in the system — funnel conversion rates, engagement metrics, billing health indicators — but they appear in supporting categories rather than the core health view. They're the labs, not the vital signs.

The Feedback Loop: Health Ranges as Institutional Memory

Here's the detail that makes this more than a dashboard.

Health ranges are institutional memory encoded as configuration. When the founding team decides that CAC under $100 is healthy but over $175 is poor, they're committing a business judgment to code. That judgment persists. It doesn't depend on the founder remembering it. It doesn't disappear when the head of growth leaves.

This is alignment feedback loop applied to business operations. The system doesn't just display data — it enforces a shared understanding of what "healthy" means. Any team member, any investor, any board member sees the same health tiers and the same color coding. There's no "well, I think our CAC is fine" when the system says "Weak."

Over time, the ranges themselves evolve. As the business matures, what counts as "Excellent" CAC shifts. The target values get updated. But they're updated deliberately, as explicit decisions, not as silent assumption drift.

What Investors See (and Why It Matters)

We didn't build this for investors. We built it because flying blind was costing us money.

But the investor implications are significant. When a founder can pull up a live health dashboard during a board meeting — not a slide deck prepared last week, but the actual live numbers with health scoring — it communicates something that slides can't: this team knows what's happening in their business right now.

The specific details that tend to get attention:

• Auto-calculated derived metrics. CAC, LTV/CAC ratio, Collection Efficiency — these aren't entered manually. They're computed from source data in real time. This eliminates the most common form of metrics fraud: rounding errors in spreadsheets that nobody double-checks.

• Direction-aware change evaluation. The system knows that churn going up is bad and conversion going up is good. This sounds trivial until you realize most dashboards don't encode this — they just show arrows and let the reader decide.

• Historical baseline comparison. "Our CAC is $87" means nothing. "Our CAC is $87, down from $94 in the baseline period, trending toward our $100 target" — that tells a story.

• Critical alert thresholds. The system proactively flags degradation. This isn't "we noticed churn was up during the board meeting." It's "the system alerted us to a churn increase on Tuesday, and here's what we did about it."

What We Still Don't Know

These are real open questions, not performative humility.

Do health ranges transfer across business stages? Our ranges are calibrated for an early-stage SaaS product with a $40/month price point. A $500/month enterprise product would have different CAC thresholds, different LTV expectations, different churn norms. We suspect the pattern transfers (encode health tiers per metric) but the values are stage-specific. We haven't tested this.

Is nine the right number? We removed metrics that didn't change decisions. But we might have been wrong about which ones are actionable. A metric that seems unactionable today (like 7-day retention) might become critical at a different growth stage. The risk is that we bake in today's priorities and miss tomorrow's signals.

Does health scoring create false confidence? When the dashboard is all green, the founder relaxes. But "green" just means the metrics are within the ranges we defined. If the ranges are wrong — if we're too generous with what counts as "Healthy" — then the system provides false reassurance. This is arguably worse than no system at all, because the founder trusts the verdict and stops thinking critically about the numbers.

Can this survive the 100-metric problem? At nine KPIs, the system is scannable. At 30 supporting metrics, it's still manageable. At 100 metrics — which is where enterprise analytics tools end up — the health scoring would need hierarchy, grouping, and priority weighting. We haven't solved that problem because we don't have it yet. But we can see it coming.

Are we measuring what we can measure, or what matters? The nine KPIs we chose are biased toward metrics that are easy to compute from existing data sources. Customer satisfaction, product-market fit, team morale — these arguably matter more than CAC, but they're hard to auto-calculate from an API. The system might be creating a baseline drift of attention: we focus on what's measured and neglect what isn't.

Building This Yourself: The Transferable Pattern

The architecture is straightforward enough to replicate. The hard part isn't the engineering — it's the business judgment required to define health ranges.

Step 1: Identify your 7-12 core KPIs. Not metrics — KPIs. The test is: if this number went critical, would you change something this week?

Step 2: For each KPI, define 5-7 health tiers with explicit numeric boundaries. This is where founders and operators need to sit together. What CAC is "too high" for your business? What churn rate is acceptable at your stage? Write these down as configuration, not as opinions.

Step 3: Tag each KPI with a direction. Higher is better, lower is better, or neutral. This enables automated evaluation of changes.

Step 4: Build the aggregation layer. Pull from your data sources on a schedule (5-minute intervals work well). Calculate derived metrics. Score each against its health ranges. Surface the result as a single view.

Step 5: Add baseline comparison. Save periodic snapshots. Compare live data against the most recent snapshot. Flag changes above a threshold (15% is a reasonable starting point).

Step 6: Revisit the ranges quarterly. As the business evolves, health ranges should evolve with it. The $100 CAC target that was ambitious in year one might be comfortably exceeded by year two.

The total engineering effort for a team that already has the data sources is roughly a week. The ongoing maintenance is near zero — the system runs itself. The value is immediate: the first time a critical alert catches a problem the founder would have missed for another two weeks, the system has paid for itself.

The metrics are always there. The question is whether they're readable — and whether someone is watching.