《独立开发者的商业指南·收入与财务工程》13.2 单位经济与估值区间

// file: src/value/unit-val.ts
// tier: L1
// verify: node --test test/value/unit-val.test.ts

import { type Cents } from "../core/money.ts";
import { type Bps, applyRate, divide } from "../core/rate.ts";
import { type Result, fail, ok } from "../core/result.ts";
import { type ScenarioRange, scenarioRange } from "./range.ts";

export type UnitEconomics = {
  monthlyGrossProfitPerCustomerCents: Cents;
  cacCents: Cents;
  monthlyChurnBps: Bps;
};

export type UnitMetrics = {
  paybackMonthsBps: Bps;
  ltvCents: Cents;
  ltvToCacBps: Bps;
  verdict: "healthy" | "watch" | "fragile";
};

export type ValuationBasis = "arr" | "sde" | "revenue";

export type UnitValuation = {
  basis: ValuationBasis;
  baseCents: Cents;
  range: ScenarioRange;
  impliedLtvMultipleBps: Bps;
};

function checkPositive(value: Cents, label: string): string | null {
  if (!Number.isInteger(value) || value <= 0) {
    return `${label} must be a positive integer amount in cents`;
  }
  return null;
}

/**
 * Payback is expressed in months, multiplied by 10000 so 2.2 months reads as
 * 22000 bps. LTV uses gross profit and monthly churn, the only combination
 * that stays comparable across the subscription cases in this book.
 */
export function unitMetrics(input: UnitEconomics): Result<UnitMetrics> {
  const grossError = checkPositive(
    input.monthlyGrossProfitPerCustomerCents,
    "monthly gross profit per customer",
  );
  if (grossError) {
    return fail(grossError);
  }
  const cacError = checkPositive(input.cacCents, "CAC");
  if (cacError) {
    return fail(cacError);
  }
  if (
    !Number.isInteger(input.monthlyChurnBps) ||
    input.monthlyChurnBps <= 0 ||
    input.monthlyChurnBps > 10000
  ) {
    return fail("monthly churn must be between 1 and 10000 bps");
  }

  const paybackMonthsBps = divide(input.cacCents, input.monthlyGrossProfitPerCustomerCents);
  // divide(a, b) already returns a / b * 10000, so dividing cents by churn in
  // bps yields cents: gross * 10000 / churnBps.
  const ltvCents = divide(
    input.monthlyGrossProfitPerCustomerCents,
    input.monthlyChurnBps,
  );
  const ltvToCacBps = divide(ltvCents, input.cacCents);

  let verdict: UnitMetrics["verdict"] = "healthy";
  if (ltvToCacBps < 30000 || paybackMonthsBps > 120000) {
    verdict = "fragile";
  } else if (ltvToCacBps < 90000 || paybackMonthsBps > 60000) {
    verdict = "watch";
  }

  return ok({ paybackMonthsBps, ltvCents, ltvToCacBps, verdict });
}

/**
 * A valuation multiple only means something next to its base. This function
 * refuses to build a range when the basis is `arr` but the base value is zero,
 * which is exactly the mistake made when a one-off product is labelled SaaS.
 */
export function unitValuation(
  basis: ValuationBasis,
  baseCents: Cents,
  baseMultipleBps: Bps,
  spreadBps: Bps,
  ltvCents: Cents,
): Result<UnitValuation> {
  const baseError = checkPositive(baseCents, "valuation base");
  if (baseError) {
    return fail(baseError);
  }
  if (!Number.isInteger(ltvCents) || ltvCents <= 0) {
    return fail("LTV must be a positive integer amount in cents");
  }
  if (basis === "arr" && baseCents === 0) {
    return fail("ARR basis requires a recurring revenue base");
  }
  const range = scenarioRange(baseCents, baseMultipleBps, spreadBps);
  if (!range.ok) {
    return range;
  }
  return ok({
    basis,
    baseCents,
    range: range.value,
    impliedLtvMultipleBps: divide(range.value.baseCents, ltvCents),
  });
}