《独立开发者的商业指南·收入与财务工程》6.1 涨价对收入与流失的净效应

收入平衡：留存客户 × 新价 = 原客户数 × 旧价
留存客户 = 260 × 77 ÷ 89 = 224.94 → 225 家
可流失客户 = 260 − 225 = 35 家
流失率上限 = 35 ÷ 260 = 13.5%

每客户月变动成本 = 38,000 ÷ 260 ÷ 12 = $12.18
旧贡献 = 77 − 12.18 = $64.82
新贡献 = 89 − 12.18 = $76.82
毛利平衡流失率 = 1 − 64.82 ÷ 76.82 = 15.62%

// file: src/price/elasticity.ts
// tier: L1
// verify: node --test test/price/elasticity.test.ts

import { type Cents, sub } from "../core/money.ts";
import { type Bps, divide, ratio } from "../core/rate.ts";
import { type Result, fail, ok } from "../core/result.ts";

export type PriceIncreaseInput = {
  baseCustomers: number;
  oldPriceCents: Cents;
  newPriceCents: Cents;
  lostCustomers: number;
  variableCostPerCustomerCents: Cents;
  monthlyChurnBps: Bps;
  months: number;
};

export type PriceIncreaseImpact = {
  baseMrrCents: Cents;
  newMrrCents: Cents;
  deltaMrrCents: Cents;
  deltaMrrBps: Bps;
  priceChangeBps: Bps;
  lostShareBps: Bps;
  revenueNeutralLossBps: Bps;
  grossProfitNeutralLossBps: Bps;
  breakEvenLostCustomers: number;
  elasticityBps: Bps;
  months: number;
  cumulativeDeltaCents: Cents;
};

function isPositiveInteger(value: number): boolean {
  return Number.isInteger(value) && value > 0;
}

function checkPricePair(oldPriceCents: Cents, newPriceCents: Cents): string | null {
  if (!isPositiveInteger(oldPriceCents) || !isPositiveInteger(newPriceCents)) {
    return "prices must be positive integer amounts in cents";
  }
  if (newPriceCents <= oldPriceCents) {
    return "new price must be above old price";
  }
  return null;
}

/**
 * The share of revenue that can be lost before a price increase stops
 * increasing revenue. It ignores variable costs: 1 - old / new.
 */
export function revenueNeutralLossBps(
  oldPriceCents: Cents,
  newPriceCents: Cents,
): Result<Bps> {
  const priceError = checkPricePair(oldPriceCents, newPriceCents);
  if (priceError) {
    return fail(priceError);
  }
  return ok(divide(sub(newPriceCents, oldPriceCents), newPriceCents));
}

/**
 * The share of customers that can be lost before a price increase stops
 * increasing gross profit. Leaving customers also stop consuming variable
 * cost, so this threshold is looser than the revenue threshold.
 */
export function grossProfitNeutralLossBps(
  oldPriceCents: Cents,
  newPriceCents: Cents,
  variableCostPerCustomerCents: Cents,
): Result<Bps> {
  const priceError = checkPricePair(oldPriceCents, newPriceCents);
  if (priceError) {
    return fail(priceError);
  }
  if (
    !Number.isInteger(variableCostPerCustomerCents) ||
    variableCostPerCustomerCents < 0
  ) {
    return fail("variable cost must be a non-negative integer amount in cents");
  }
  const newContribution = sub(newPriceCents, variableCostPerCustomerCents);
  if (newContribution <= 0) {
    return fail("variable cost must be below the new price");
  }
  return ok(
    divide(sub(newPriceCents, oldPriceCents), newContribution),
  );
}

/**
 * Number of customers that can leave while retained revenue stays at or above
 * the old revenue level. Retained customers are rounded up to whole customers.
 */
export function breakEvenLostCustomers(
  baseCustomers: number,
  oldPriceCents: Cents,
  newPriceCents: Cents,
): Result<number> {
  if (!isPositiveInteger(baseCustomers)) {
    return fail("base customers must be a positive integer");
  }
  const priceError = checkPricePair(oldPriceCents, newPriceCents);
  if (priceError) {
    return fail(priceError);
  }
  const retained = Math.ceil((baseCustomers * oldPriceCents) / newPriceCents);
  return ok(baseCustomers - retained);
}

/**
 * Sum of monthly retention factors over the horizon. Month zero counts as a
 * full month of revenue, so a one-month horizon returns exactly 1.
 */
function retentionSum(months: number, monthlyChurnBps: Bps): number {
  const keep = 1 - ratio(monthlyChurnBps);
  let sum = 0;
  let factor = 1;
  for (let month = 0; month < months; month += 1) {
    sum += factor;
    factor *= keep;
  }
  return sum;
}

export function priceIncreaseImpact(
  input: PriceIncreaseInput,
): Result<PriceIncreaseImpact> {
  const priceError = checkPricePair(input.oldPriceCents, input.newPriceCents);
  if (priceError) {
    return fail(priceError);
  }
  if (!isPositiveInteger(input.baseCustomers)) {
    return fail("base customers must be a positive integer");
  }
  if (
    !Number.isInteger(input.lostCustomers) ||
    input.lostCustomers < 0 ||
    input.lostCustomers > input.baseCustomers
  ) {
    return fail("lost customers must be between zero and base customers");
  }
  if (
    !Number.isInteger(input.variableCostPerCustomerCents) ||
    input.variableCostPerCustomerCents < 0
  ) {
    return fail("variable cost must be a non-negative integer amount in cents");
  }
  if (
    !Number.isInteger(input.monthlyChurnBps) ||
    input.monthlyChurnBps < 0 ||
    input.monthlyChurnBps > 10000
  ) {
    return fail("monthly churn must be between 0 and 10000 bps");
  }
  if (!isPositiveInteger(input.months)) {
    return fail("months must be a positive integer");
  }

  const baseMrrCents = input.baseCustomers * input.oldPriceCents;
  const retained = input.baseCustomers - input.lostCustomers;
  const newMrrCents = retained * input.newPriceCents;
  const deltaMrrCents = sub(newMrrCents, baseMrrCents);
  const priceChangeBps = divide(
    sub(input.newPriceCents, input.oldPriceCents),
    input.oldPriceCents,
  );
  const lostShareBps = divide(input.lostCustomers, input.baseCustomers);
  const elasticityBps =
    lostShareBps === 0
      ? 0
      : -Math.round((lostShareBps * 10000) / priceChangeBps);
  const revenueThreshold = revenueNeutralLossBps(
    input.oldPriceCents,
    input.newPriceCents,
  );
  if (!revenueThreshold.ok) {
    return revenueThreshold;
  }
  const grossProfitThreshold = grossProfitNeutralLossBps(
    input.oldPriceCents,
    input.newPriceCents,
    input.variableCostPerCustomerCents,
  );
  if (!grossProfitThreshold.ok) {
    return grossProfitThreshold;
  }
  const breakEven = breakEvenLostCustomers(
    input.baseCustomers,
    input.oldPriceCents,
    input.newPriceCents,
  );
  if (!breakEven.ok) {
    return breakEven;
  }

  return ok({
    baseMrrCents,
    newMrrCents,
    deltaMrrCents,
    deltaMrrBps: divide(deltaMrrCents, baseMrrCents),
    priceChangeBps,
    lostShareBps,
    revenueNeutralLossBps: revenueThreshold.value,
    grossProfitNeutralLossBps: grossProfitThreshold.value,
    breakEvenLostCustomers: breakEven.value,
    elasticityBps,
    months: input.months,
    cumulativeDeltaCents: Math.round(
      deltaMrrCents * retentionSum(input.months, input.monthlyChurnBps),
    ),
  });
}