Summary: This is a production-ready Markdown template and technical specification that defines inputs, outputs, underlying mathematics, implementation notes (spreadsheet + JavaScript), examples, and prescriptive best practices for building a Burn Rate Calculator tool. Given current cash, period granularity, recurring revenue and outflows, and planned changes, the calculator deterministically computes runway (time to zero) and quantifies sensitivity to decisions like hiring, pricing, and fundraising for use in web tools, spreadsheets, investor decks, or internal dashboards.

Burn Rate Calculator Template & Technical Spec

A professional, production-ready Markdown template for a Burn Rate Calculator tool. This document defines the inputs, outputs, underlying mathematics, implementation notes (spreadsheet + JavaScript), examples, and prescriptive best practices for founders and operators.

Use this as the single source of truth when building a web tool, spreadsheet, investor deck slide, or internal finance dashboard.

One-line summary

Burn Rate Calculator = a deterministic cash-flow countdown: given current cash, recurring inflows and outflows, and planned changes, compute how long the company can operate before cash reaches zero (runway), and quantify sensitivity to decisions (hiring, pricing, fundraising).

Inputs (required)

• Cash on Hand (C0) current liquid runway cash balance (USD)
• Period Granularity monthly (default), weekly, daily
• Monthly Recurring Revenue (MRR) or Revenue per period (R)
• Total Cash Outflows per period (O) all operating expenses paid in cash (payroll, rent, marketing, CapEx, one-time planned spends)
  Optionally broken down:
  • Payroll
  • R&D / Product
  • Sales & Marketing
  • G&A / Ops
  • One-time or capital expenses (amortized or placed in schedule)
• Optional one-time cash events:
  • One-time inflows (e.g., grants, convertible note)
  • One-time outflows (e.g., legal, CapEx)
• Planned future changes (time-indexed):
  • Delta payroll at month t (hire or layoff)
  • Revenue growth schedule (absolute or % per period)
  • Planned fundraising (amount and expected close date)
• Safety / buffer rules:
  • Minimum runway target (months)
  • Emergency headcount reduction percentage (trigger)
• Time horizon for projection (e.g., 36 months)

Outputs (derived)

• Gross Burn (B_g) total cash outflows per period
• Net Burn (B_n) net cash outflow per period = outflows − inflows
• Runway (months) time until cash reaches zero at current net burn
• Runway under scenarios (hiring/scaling/fundraising)
• Cash schedule over projection horizon (C(t))
• Warning flags (e.g., runway < target, runway breach date)
• Key ratios:
  • Burn Efficiency = Net Burn / Revenue (percent of revenue consumed)
  • Months of runway per $1M (normalization)

Core math & formulas

Definitions (per period; default period = month):

• Cash on hand: C0
• Revenue per period: R (MRR)
• Outflows per period (gross burn): B_g
• Net burn per period: B_n = B_g − R

Runway (in periods):

• If B_n > 0:
  • Runway = C0 / B_n
• If B_n ≤ 0:
  • Runway = ∞ (company is cash-flow neutral or cash-generating)

Discrete cash evolution (no financing during projection):

• C(t) = C0 − t * B_n, for integer t = 0, 1, 2, ...
• Runway = min t such that C(t) ≤ 0 = C0 / B_n

Including one-time inflows/outflows at times {τi}:

• C(t) = C0 + Σ_{τi ≤ t} ΔCi − t * B_n (if B_n constant)
• More generally, if net burn is time-dependent B_n(t):
  • C(t) = C0 + Σ_{τi ≤ t} ΔCi − Σ_{k=1..t} B_n(k)
  • Runway is the smallest t with C(t) ≤ 0

If revenue grows geometrically at rate g per period, starting R0:

• R(t) = R0 * (1 + g)^t
• B_n(t) = B_g − R(t)
• C(t) = C0 + Σ_{k=1..t} (R(k) − B_g)
• Solve for t numerically where C(t) ≤ 0 (closed-form not generally available)

If revenue grows linearly: R(t) = R0 + α t

• B_n(t) = B_g − (R0 + α t)
• C(t) = C0 + Σ_{k=1..t} (R0 + α k − B_g) = C0 + t(R0 − B_g) + α * t(t+1)/2
• Solve quadratic for t where C(t) = 0

Edge case handling:

• If B_n ≤ 0 at t=0 and future negative net burn expected (profit), report runway = ∞ and show time-to-profit metrics.
• If one-time large outflow creates a temporary runway breach, show date and recovery path separately.

Spreadsheet implementation (Google Sheets / Excel)

Assume monthly granularity, columns by month (0..N).

Basic cells:

• A1: Cash on Hand (C0) e.g., 1,500,000
• A2: Monthly Revenue (R) e.g., 80,000
• A3: Gross Burn (B_g) e.g., 200,000
• A4: Net Burn (B_n) = A3 − A2
• A5: Runway (months) = IF(A4>0, A1 / A4, "Infinite")

Row-by-row projection (columns B..AF for months 0..36):

• Row: Month index: 0, 1, 2, ...
• Row: Revenue: = previous revenue * (1 + growth_rate) or static
• Row: Outflows: = base_outflows + planned_changes[t]
• Row: Net burn: = Outflows − Revenue
• Row: Cash: = previous_cash − net_burn
• Runway date: first column where Cash <= 0

Sample formulas:

• B4 (net burn): =B3 - B2
• B5 (cash month 0): =C0
• C5 (cash month 1): =B5 - C4
• Copy across; detect runway month with MATCH(TRUE, cash_row<=0,0)

Validation:

• Protect formula rows; highlight negative revenue; warn when net burn increases > 15% month-over-month.

JavaScript snippet (core calculation)

A concise function to compute runway given constant per-period net burn:

// Returns runway in periods (months) or Infinity
function runwayMonths(cashOnHand, revenuePerPeriod, outflowsPerPeriod) {
  const netBurn = outflowsPerPeriod - revenuePerPeriod;
  if (netBurn <= 0) return Infinity;
  return cashOnHand / netBurn;
}

A small simulator (time-dependent changes):

function simulateCashSchedule({
  cashOnHand, months, revenueSchedule, outflowSchedule, oneTimeEvents = {}
}) {
  // revenueSchedule and outflowSchedule arrays length >= months
  const cash = [cashOnHand];
  for (let t = 1; t <= months; t++) {
    const r = revenueSchedule[t-1] || 0;
    const o = outflowSchedule[t-1] || 0;
    const oneTime = oneTimeEvents[t] || 0; // positive inflow, negative outflow
    const next = cash[t-1] + oneTime + (r - o);
    cash.push(next);
    if (next <= 0) {
      return { cash, runwayMonth: t, breached: true };
    }
  }
  return { cash, runwayMonth: null, breached: false };
}

Example (concise)

Inputs:

• Cash = $1,500,000
• MRR = $80,000
• Gross monthly outflows = $200,000

Compute:

• Net burn = 200,000 − 80,000 = $120,000 / month
• Runway = 1,500,000 / 120,000 = 12.5 months

If you hire 2 engineers increasing payroll by $40,000/month:

• New net burn = 160,000 − 80,000 = 80,000 → Runway = 1,500,000 / 160,000 = 9.375 months
  (Important: above second run uses new gross burn 240k and net burn 160k? Wait ensure correct: If payroll +40k increases outflows to 240k: net burn = 240k−80k=160k => runway 1.5M/160k = 9.375 months.)

Show scenario table with hires, hires + marketing ramp, fundraising events, etc.

Conceptual explanation how it works (authoritative)

1. The burn rate is a cash-centric metric. It measures how quickly a company consumes cash reserves after accounting for revenue. It is not an accounting "expense" number; it is cash flow.
2. Gross burn = all cash outflows (payroll, vendor payments, rent, taxes, CapEx). Net burn = gross burn − cash inflows (revenue). Use net burn for runway calculations.
3. Runway = how long current cash will last at the current cadence of net cash consumption. It is a forecast, not a guarantee. Real businesses have irregular/cyclical cash events; model them explicitly (one-time payments, seasonal revenue).
4. Use discrete or continuous modeling depending on granularity: startups typically model monthly. If you have weekly payroll or daily trading, use equivalently smaller period.
5. Scenario planning is essential: runway changes materially with hires, pricing, sales cycles, and funding timing. Model multiple scenarios (base, optimistic, pessimistic) and sensitivity to core drivers (MRR growth, churn, hiring).
6. The calculus for "raise now vs later" should include: runway at different raise sizes, dilution tolerance, and milestone-based capital efficiency. Aim to raise when you have 9–12 months left (or earlier if you expect market volatility). Communicate transparently with investors.
7. Cash runway takes precedence over many vanity KPIs when survival is at stake. Align hiring, marketing, and burn decisions to extend runway while maximizing value creation (ARR, product-market fit).

Best practices for founders (highly actionable)

• Measure cash weekly; forecast monthly. Weekly cadence catches payroll timing, vendor settlements, and subscription churn.
• Distinguish cash vs non-cash. Stock-based comp and depreciation are real economic costs, but runway uses cash flows (taxes, employer payroll taxes, benefits are cash).
• Maintain at least a 12-month runway target before raising (common early-stage rule). For growth-stage companies with predictable revenue, 12–18 months is typical; for pre-seed/seed, 12–24 months depends on speed to traction.
• Keep a rolling 12–18 month forecast that is updated monthly with variance analysis (actual vs forecast) and root causes.
• Create scenario buckets: base (median assumptions), pessimistic (-20% revenue, +10% costs), optimistic (+20% revenue, +5% costs). Report runways for each.
• Stress test hires: quantify marginal contribution per hire vs marginal cash cost. Apply a payback period for acquisition-focused roles (e.g., sales hire CAC payback).
• Tie hiring and burn commitments to milestones. Example: hire only once MRR crosses $X or conversion metrics hit defined thresholds.
• Build funding cadence into runway plan: if runway < 12 months, initiate fundraising immediately. Fundraising often takes 3–6 months.
• Track burn efficiency and unit economics: CAC payback, LTV:CAC, contribution margin. Use these to convert burn into scalable growth (spend with ROI).
• Report transparently to investors: show cash balance, net burn, runway, 3-scenario projections, major one-time events, and hiring plan.
• Maintain a contingency playbook: which expenses to cut first, how fast to downsize, and legal/HR/tax implications. Quantify impacts of each action on runway before executing.
• Automate: connect your accounting system (e.g., QuickBooks, Stripe) to update revenue and outflow inputs. Use alerts for runway thresholds.
• Keep some runway uncommitted (buffer). Conservatively assume slower revenue conversion than plan; set buffer of 10–30% on projected burn depending on stage and market.

Recommended thresholds & heuristics (stage-aware)

• Pre-seed / Seed: aim for 12–24 months runway; prioritize product-market fit. Prefer lower burn until repeatable acquisition is proven.
• Series A: 12–18 months post-raise runway; use capital to scale core GTM if unit economics are healthy.
• Growth stage: 18–36 months runway is common during aggressive scale cycles, but requires strict measurement of payback and capital efficiency.
• Emergency trigger: runway ≤ 6 months → immediate board-level contingency planning and tighten hiring/spend.
• Fundraising trigger: begin process when runway = 9–12 months (timing depends on lead investor availability & market).

UX considerations for a tool/UI

• Input sanity checks: prevent negative revenues/outflows; require nonzero cash.
• Output clarity: show numeric runway + human-friendly date when runway will be exhausted.
• Visuals: cash balance timeline (area chart), net burn waterfall (expense categories), scenario comparison overlay.
• Export: CSV/Excel and PDF summary for investor communications.
• Accessibility: colorblind-safe palettes for charts; numeric tooltips for each point.
• Security: encrypt stored financial inputs; follow SOC 2 practices if used in production.

Common pitfalls & FAQ

• Pitfall: using EBITDA or GAAP P&L instead of cash flows this misleads runway estimates.
  • Fix: use cash-based outflows; account for timing differences (deferred revenue, receivables).
• Pitfall: ignoring one-time or irregular events.
  • Fix: model one-time events separately and show adjusted runway.
• Question: "What if net burn becomes negative later?"
  • Answer: compute time-to-positive-cash (cumulative cash becomes positive) via full C(t) simulation and show breakeven month.
• Question: "How to account for seasonality?"
  • Answer: use monthly schedules that reflect seasonality in revenue and spend; run multi-year horizon.

Implementation checklist (developer handoff)

• Define canonical input schema (JSON):
  • { cashOnHand, period, revenueSchedule[], outflowSchedule[], oneTimeEvents: [{month, amount}], plannedFundraises: [{month, amount}], metadata }
• Implement deterministic simulator returning cash array and runway month.
• Build exportable CSV and PDF summarizer.
• Add sensitivity engine: vary revenue ±10/20/30% and costs ±10/20/30% and compute runways.
• Add governance flags: runway < target triggers email to founders and CFO.
• Unit tests: constant-burn, time-varying-burn, one-time-event, infinite-runway case.

This template provides the technical backbone and operational playbook for an accurate, defensible Burn Rate Calculator. Use it to build tools that inform board decisions, fundraising cadence, hiring plans, and contingency preparation. If you want, I can convert this into a live spreadsheet template, React component, or a deployable microservice (API + UI) with the simulation engine and visualizations.