Comparison with On-Premises

The previous lesson compared three deployment layouts in terms of control, fixedness, and elasticity, and no money changed hands anywhere in it. Yet the difference between “100% fixed reserved capacity” and “0%” really shows itself in a payment form: one up front and once, the other continuous and by usage. This lesson runs those two payment forms on the same usage curve.

The result of the comparison cannot be reduced to a single sentence, because the result depends on the shape of the usage curve and how long you stay. These two variables are what is measured: the month capital expense’s cumulative spend drops below operating expense — the break-even point — and where that point shifts as the curve changes.

Every cost in this lesson is fictional. There is no real currency, real price list, or real provider; everything is written in a fictional unit (fu). The meaning of the numbers is not in their size but in their ratios to one another.

Two Payment Forms and Six Items

The example is the course’s fictional regional measurement network: the reading collector, the validator, billing and work-order services, a nightly batch job, five teams. Both the network and the services are fictional; the cost structure below is a model.

CC19: the model runs a 36-month window; every cost is fictional and written in fu. CC20: under own hardware, 110 fu is paid once per capacity unit, the smallest purchase is 4 units, and unit lifespan is 36 months; each installed unit adds 3 fu of operating labor a month, and a 20 fu facility fee accrues every month the setup stays up. CC21: under renting, the unit-month is 12 fu; each unit-month covers 36,000 requests, and every 1,000 requests cost 0.05 fu, meaning 1.8 fu of request fee is added per unit-month; a one-time 250 fu exit fee accrues at exit. CC22: capacity meets demand every month; own hardware is purchased in four-unit blocks and never reduced, renting matches demand exactly every month. CC23: the visible total counts only the two visible items — the hardware’s upfront cost and the unit-month lease; the full total counts all six items. CC24: at exit, 40% of own hardware’s residual book value comes back; under renting, the exit fee is added once.

// cloud/cost.mjs — the model that runs capital expense against operating expense on the same
// usage curve. All costs are FICTIONAL and are written in a fictional unit (fu); there is no
// real currency, real price list, or real provider. No randomness.

export const MONTHS = 36;
export const F = {
  upfront: 110,   // own hardware: per capacity unit, once (fictional fu)
  block: 4,       // own hardware: smallest purchase
  lifespan: 36,   // own hardware: unit lifespan (months)
  labor: 3,       // own hardware: per installed unit per month (operating labor)
  facility: 20,   // own hardware: fixed per month (power, cooling, siting)
  rent: 12,       // renting: unit-month (on-demand capacity)
  request: 1.8,   // renting: per-request fee per unit-month
  exit: 250,      // renting: once at exit (data transfer)
  recovery: 0.4,  // own hardware: recoverable share of residual book value at exit
};

// Cost items: side, visible (read at first glance in the contract/invoice), description.
export const ITEM = `
  hardware-upfront        own   visible
  operating-labor         own   hidden
  facility-power-cooling  own   hidden
  unit-month-lease        rent  visible
  per-request-fee         rent  hidden
  exit-fee                rent  hidden`
  .trim().split("\n").map((r) => {
    const [name, side, v] = r.trim().split(/\s+/);
    return { name, side, visible: v === "visible" };
  });

const BASE = {
  flat: () => 5,
  peak: (m) => (m >= 14 && m < 20 ? 16 : 5),
  growing: (m) => 3 + 0.4 * m,
};
export const curve = (name) => Array.from({ length: MONTHS }, (_, m) => Math.ceil(BASE[name](m)));

// mode "visible": only the visible items are counted. mode "full": every item is counted.
export function run(curveName, mode) {
  const T = curve(curveName), g = (name) => mode === "full" || ITEM.find((k) => k.name === name).visible;
  const purchases = [];                             // {month, units} own-hardware purchases
  let cap = 0;
  const own = [], rent = [];
  let ownSum = 0, rentSum = 0;
  for (let m = 0; m < MONTHS; m++) {
    while (cap < T[m]) { cap += F.block; purchases.push({ month: m, units: F.block }); }
    if (g("hardware-upfront")) ownSum += purchases.filter((x) => x.month === m).length * F.block * F.upfront;
    if (g("operating-labor")) ownSum += cap * F.labor;
    if (g("facility-power-cooling")) ownSum += F.facility;
    if (g("unit-month-lease")) rentSum += T[m] * F.rent;
    if (g("per-request-fee")) rentSum += T[m] * F.request;
    own.push(ownSum); rent.push(rentSum);
  }
  return { T, purchases, cap, own, rent };
}

// Break-even: the first month (1-based) the own-hardware cumulative spend drops to or below rent.
export function breakEven(r) {
  for (let m = 0; m < MONTHS; m++) if (r.own[m] <= r.rent[m]) return m + 1;
  return null;
}

// Exit: net cost if leaving that month. Under own hardware, a share of the residual book value of
// units purchased so far comes back; under renting, an exit fee is added once.
export function exitCost(r, month, mode) {
  const residual = r.purchases.filter((x) => x.month < month).reduce((s, x) =>
    s + x.units * F.upfront * Math.max(0, F.lifespan - (month - x.month)) / F.lifespan, 0) * F.recovery;
  const extra = mode === "full" ? F.exit : 0;
  return { own: Math.round(r.own[month - 1] - residual), rent: Math.round(r.rent[month - 1] + extra) };
}

// cloud/measure.mjs — the break-even point, how it shifts when the usage curve changes, and hidden items.
import { run, breakEven, exitCost, curve, ITEM, F, MONTHS } from "./cost.mjs";

const write = (w, ...s) => console.log(s.map((v, i) =>
  (w[i] < 0 ? String(v).padEnd(-w[i]) : String(v).padStart(w[i]))).join(""));
const CURVE = ["flat", "peak", "growing"];
const R = Object.fromEntries(CURVE.flatMap((c) => ["visible", "full"]
  .map((mode) => [`${c}-${mode}`, run(c, mode)])));
const month = (b) => (b === null ? `>${MONTHS}` : b);

console.log(`${MONTHS}-month window; all costs are FICTIONAL and are written in a fictional unit (fu). ` +
  `capacity unit: upfront ${F.upfront}, rent ${F.rent}/month`);

const A = [-24, 9, 12, 34];
console.log("\n1. cost items (visible = read at first glance in the contract)");
write(A, "item", "side", "visible", "fictional fee");
const FEE = { "hardware-upfront": `${F.upfront} fu / unit, once`,
  "operating-labor": `${F.labor} fu / installed unit-month`,
  "facility-power-cooling": `${F.facility} fu / month`,
  "unit-month-lease": `${F.rent} fu / unit-month`,
  "per-request-fee": `${F.request} fu / unit-month`,
  "exit-fee": `${F.exit} fu, once` };
for (const k of ITEM) write(A, k.name, k.side, k.visible ? "yes" : "no", FEE[k.name]);

const B = [-10, 12, 12, 10, 15, 13];
console.log("\n2. break-even month: when own hardware overtakes renting");
write(B, "curve", "lowest", "highest", "purchase", "visible total", "full total");
for (const c of CURVE) {
  const T = curve(c);
  write(B, c, Math.min(...T), Math.max(...T), R[`${c}-full`].cap,
    month(breakEven(R[`${c}-visible`])), month(breakEven(R[`${c}-full`])));
}

const C = [-10, 13, 11, 13, 14, 11, 13];
console.log(`\n3. cumulative spend at month ${MONTHS} (fu) and the hidden share`);
write(C, "curve", "own visible", "own full", "hidden (%)", "rent visible", "rent full",
  "hidden (%)");
const share = (v, f) => `${Math.round(f - v)} (${Math.round(((f - v) / f) * 100)})`;
for (const c of CURVE) {
  const v = R[`${c}-visible`], f = R[`${c}-full`], i = MONTHS - 1;
  write(C, c, v.own[i], Math.round(f.own[i]), share(v.own[i], f.own[i]),
    v.rent[i], Math.round(f.rent[i]), share(v.rent[i], f.rent[i]));
}

const D = [-10, 12, 12, 12, 12, 12];
console.log(`\n4. net cost by exit month under the full ledger (fu; ` +
  `${F.recovery * 100}% of residual book value comes back)`);
write(D, "curve", "exit month", "own", "rent", "gap", "winner");
for (const c of CURVE) for (const m of [12, 24, 36]) {
  const e = exitCost(R[`${c}-full`], m, "full");
  write(D, c, m, e.own, e.rent, e.own - e.rent, e.own < e.rent ? "own" : "rent");
}

36-month window; all costs are FICTIONAL and are written in a fictional unit (fu). capacity unit: upfront 110, rent 12/month

1. cost items (visible = read at first glance in the contract)
item                         side     visible                     fictional fee
hardware-upfront              own         yes               110 fu / unit, once
operating-labor               own          no       3 fu / installed unit-month
facility-power-cooling        own          no                     20 fu / month
unit-month-lease             rent         yes                12 fu / unit-month
per-request-fee              rent          no               1.8 fu / unit-month
exit-fee                     rent          no                      250 fu, once

2. break-even month: when own hardware overtakes renting
curve           lowest     highest  purchase  visible total   full total
flat                 5           5         8             15           36
peak                 5          16        16             19          >36
growing              3          17        20             13           23

3. cumulative spend at month 36 (fu) and the hidden share
curve       own visible   own full   hidden (%)  rent visible  rent full   hidden (%)
flat                880       2464    1584 (64)          2160       2484     324 (13)
peak               1760       3872    2112 (55)          2952       3395     443 (13)
growing            2200       4216    2016 (48)          4488       5161     673 (13)

4. net cost by exit month under the full ledger (fu; 40% of residual book value comes back)
curve       exit month         own        rent         gap      winner
flat                12        1173        1078          95        rent
flat                24        1819        1906         -87         own
flat                36        2464        2734        -270         own
peak                12        1173        1078          95        rent
peak                24        2684        2817        -133         own
peak                36        3735        3645          90        rent
growing             12        1123        1175         -52         own
growing             24        2499        2900        -401         own
growing             36        3864        5411       -1547         own

The numbers are in the measurement class; their inputs are CC19–CC24, and all of them are fictional costs.

The Break-Even Point

The second table runs the same calculation twice. The visible total counts only the two items read at first glance in the contract: the hardware’s upfront cost and the unit-month lease. Under this count, break-even is month 15 in the flat curve, month 19 in the peak-forming curve, month 13 in the growing curve. These three numbers are where the sentence “it pays for itself in two years” comes from.

The full total counts all six items, and across the same three curves break-even shifts to month 36, past the window, and month 23. The shift is 21 months in the flat curve, past the window in the peak-forming curve, 10 months in the growing curve. The break-even point is not a fact but a result of which items were taken into the count; the gap between the two totals shows that the sides of the argument are often not measuring the same thing.

Where Break-Even Shifts When the Curve Changes

The three curves run the same service under three different demand shapes. In the flat curve, demand is 5 units for all 36 months; own hardware buys 8 units because of the four-unit block, and carries the extra for its entire lifespan. Under the full total, break-even sits right at the end of the window — meaning it only breaks even if you stay for the full three years.

In the peak-forming curve, demand climbs from 5 to 16 units over six months and then drops back. Own hardware climbs to 16 units to cover that peak and keeps holding 16 even after the peak has passed; renting pays through the peak and then comes back down. Under the full total, break-even falls outside the window. A single six-month peak reverses a three-year investment decision.

In the growing curve, demand climbs steadily from 3 to 17 units. Here own hardware gives the earliest break-even (month 23), because renting pays a little more every month and total rent reaches 5,161 fu by month 36 — the highest of the three curves. Where renting costs you is a predictably growing load; there, nothing is gained from elasticity, because capacity never comes back down in the first place.

Hidden Items

The third table writes the gap between the two totals as an item. Under own hardware at month 36, the visible total is 880 fu in the flat curve and the full total 2,464 fu: 1,584 fu hidden, 64% of the total. It is 55% in the peak-forming curve and 48% in the growing curve. The hidden items have known names — operating labor per installed unit and the monthly facility fee — and neither shows up in a purchase decision, because neither appears on the hardware invoice.

Under renting the same share is 13% across all three curves, and its only source is the per-request fee. The share being low and constant does not mean renting is more honest; renting’s biggest hidden item is not in this table at all, because that item is born only at exit.

The direction the hidden share moves from curve to curve says something too. Under own hardware the share is highest in the flat curve (64%) and lowest in the growing curve (48%) — because as upfront hardware spending grows in the growing curve, the visible item’s share grows with it. In other words, the hidden part of the ledger is largest under low usage: when hardware is used lightly, the upfront cost stays small, but operating labor and the facility fee run at full strength from day one. Under renting, the share staying independent of the curve is because that side’s hidden item is proportional to usage.

The Exit Month Changes the Winner

The fourth table cuts the same three curves at three different exit months and counts the exit items too: under own hardware, 40% of residual book value comes back; under renting, a 250 fu exit fee is added.

In the flat curve, renting leads by 95 fu at month 12, own hardware leads by 87 fu at month 24, and by 270 fu at month 36. In the peak-forming curve the lead flips twice: renting at month 12, own hardware at month 24, renting again at month 36 (by 90 fu). In the growing curve own hardware leads at all three cuts, and the gap widens to 1,547 fu by month 36.

The peak-forming curve flipping direction twice is this lesson’s main finding. There is no correct answer to the decision; what determines the answer is how long you stay, and that duration is unknown at decision time. What own hardware loses on early exit is the 60% of residual book value that never comes back; what renting loses on late exit is the accumulated unit-month lease. Both sides are buying a kind of lock-in: one to an asset, the other to a contract.

Summary

• The break-even month is 15, 19, and 13 under the visible total; 36, past the window, and 23 under the full total. The shift is 21 months, past the window, and 10 months in turn; break-even is not a fact but a result of which items are taken into the count.
• Under own hardware, hidden items hold 64%, 55%, and 48% of the total at month 36; under renting the same share is 13% across all three curves, and its only source is the per-request fee.
• In the peak-forming curve, own hardware climbs to 16 units and keeps holding them even after the peak passes; a single six-month peak throws the full-total break-even outside the 36-month window.
• Where renting costs you is a predictably growing load: there, total rent climbs to 5,161 fu by month 36, and break-even drops to month 23.
• The exit month changes the winner: in the flat curve, renting at month 12, own hardware at months 24 and 36; in the peak-forming curve the lead flips twice (renting at month 12, own hardware at month 24, renting again at month 36).
• The hidden items have known names — operating labor and facility under own hardware, the per-request fee and the exit fee under renting; neither appears on the document the decision is made from.

Next Step

This lesson turned renting’s cost into money and showed that the winner changes depending on which items the count takes in. But one item was never asked throughout the whole table: when something goes wrong in the rented service, who was supposed to have done it. The operating-labor item is a single number under own hardware; under renting, part of that labor passes to the provider — but exactly which part? The next lesson builds a responsibility matrix: item by item, which side, how many items fall into the gap, and how many overlap.