--- title: 'Standardization and Autonomy Balance' source: 'https://academia.sh/en/courses/platform-engineering/standardization-and-autonomy-balance' course: 'Platform Engineering' language: en updated: '2026-09-13T05:08:29+00:00' license: 'CC BY-SA 4.0' objectives: - 'Runs ten items in three modes and counts the number of distinct choices born in each item alongside the value the shared tool provides' - 'Counts the legitimate requirements and the habits mandate blocks separately and compares their costs' - 'Shows the gap between guardrail and wall in person-days and derives the best mode per item' --- # Standardization and Autonomy Balance Measuring mandate and freedom of choice together: each of ten items is run in mandatory, default, and free modes, the number of distinct choices born and the number of items where the shared tool still works are counted side by side, how many teams' legitimate requirements mandate blocks is derived, and the gap between guardrail and wall is shown in person-days. The previous lesson wrote the golden path as a scope and counted both sides of it: the gain for those who stay inside, the loss for those left outside. Throughout the table, teams' requirements were held fixed, and the path fit them only as much as it fit. The question that went unasked was this: **was entering the path mandatory?** Mandate and freedom of choice are two ends of the same axis, and each has its own measure. Mandate produces **alignment**: if an item has only one choice, a single shared tool is enough to cover it. Freedom produces **diversity**: every team picks what fits its own work, but the shared tool becomes useless as the option count grows. This lesson counts both in the same table and separates two distinct forms of mandate. The through-line is the regional measurement network and its five teams; both the network and the teams are fictional. ## Three Modes and Ten Items **PA19 — each of the ten items is run in one of three modes: mandatory, default but changeable, free.** Every item has a **shared-tool value**: the person-days gained yearly if that item stays at a single option across the whole organization. **PA20 — every team's per-item preference is written down along with the reason for it; the reason is either a legitimate requirement the work calls for, or the team's habit.** The reason: mandate blocks both, but they do not cost the same, and that cannot be measured without separating them. **PA21 — the number of distinct choices born in an item is diversity; the shared tool gives its full value if the choice count is one, half if it is two, and nothing at three or above.** In free mode, the platform proposes no option at all, and teams with no preference build their own choice too. The reason: with no default option, teams have no reason to converge on the same point. **PA22 — mandate is run in two forms. Wall allows no exception at all; guardrail grants an exception for a legitimate reason, and not for habit.** The reason: in practice "mandatory" is not a single thing, and the difference between the two only shows up in the count of blocked legitimate requirements. ```js // mode.mjs — every item is run in three modes: mandatory, default, free (model) import { writeFileSync } from "node:fs"; // PA19 — each of the ten items is run in one of three modes. Every item has a "shared-tool // value": the person-days gained yearly across the whole organization if that item stays at a // single option. PA20 — every team's per-item preference is written as a string: "-" accepts // the default, "2m" wants option two for a legitimate requirement, "3a" wants option three // out of habit. Team order: meter reading, validation, billing, field, reporting. Fictional. const TEAM = ["meter reading", "validation", "billing", "field", "reporting"]; const ITEM = [ ["log format", 14, "- - - - -"], ["dashboard naming", 12, "- - 2a - -"], ["base image", 11, "- - - 2m -"], ["secret store", 10, "2m - - - -"], ["deployment step order", 8, "- 2a - 3m -"], ["test threshold", 7, "- 2m - - 3a"], ["language version", 6, "- - 2m - -"], ["network rule format", 5, "2m - - 2m -"], ["data store version", 4, "2m 3a - 4m -"], ["backup interval", 3, "- - 2m 3a 4a"], ].map(([name, shared, row]) => ({ name, shared, preferences: row.split(" ").map((s) => s === "-" ? null : { option: parseInt(s, 10), legitimate: s.endsWith("m") }) })); // PA21 — the number of distinct choices born in an item is diversity; the shared tool gives its // full value if the choice count is 1, half (rounded down) if it is 2, and nothing at 3 or above. // In free mode the platform proposes no option at all; every team with no preference builds its // own choice too. The reason: with no default option, teams have no reason to converge on the same point. const MODE = { wall: (t) => 1, guardrail: (t) => (t && t.legitimate ? t.option : 1), default: (t) => (t ? t.option : 1), free: (t, i) => (t ? t.option : 100 + i), }; const selections = (k, mode) => k.preferences.map((t, i) => MODE[mode](t, i)); const diversity = (k, mode) => new Set(selections(k, mode)).size; const alignment = (k, mode) => { const c = diversity(k, mode); return c === 1 ? k.shared : c === 2 ? Math.floor(k.shared / 2) : 0; }; const blocked = (k, mode, legitimate) => k.preferences.filter((t, i) => t && t.legitimate === legitimate && MODE[mode](t, i) !== t.option).length; writeFileSync("mode.json", JSON.stringify({ TEAM, ITEM })); const MODES = ["wall", "guardrail", "default", "free"]; console.log("item".padEnd(23) + "shared".padStart(7) + MODES.map((x) => `${x} d/a`.padStart(16)).join("") + "blocked l/h".padStart(12)); for (const k of ITEM) console.log(k.name.padEnd(23) + `${k.shared}`.padStart(7) + MODES.map((x) => `${diversity(k, x)} / ${alignment(k, x)}`.padStart(16)).join("") + `${blocked(k, "wall", true)} / ${blocked(k, "wall", false)}`.padStart(12)); const T = (f) => ITEM.reduce((t, k) => t + f(k), 0); console.log("TOTAL".padEnd(23) + `${T((k) => k.shared)}`.padStart(7) + MODES.map((x) => `${T((k) => diversity(k, x))} / ${T((k) => alignment(k, x))}`.padStart(16)).join("") + `${T((k) => blocked(k, "wall", true))} / ${T((k) => blocked(k, "wall", false))}`.padStart(12)); console.log("\nd = number of distinct choices born in the item, a = person-days the shared tool gives"); console.log("blocked l/h = legitimate requirements / habits blocked in wall mode"); ``` ``` item shared wall d/a guardrail d/a default d/a free d/a blocked l/h log format 14 1 / 14 1 / 14 1 / 14 5 / 0 0 / 0 dashboard naming 12 1 / 12 1 / 12 2 / 6 5 / 0 0 / 1 base image 11 1 / 11 2 / 5 2 / 5 5 / 0 1 / 0 secret store 10 1 / 10 2 / 5 2 / 5 5 / 0 1 / 0 deployment step order 8 1 / 8 2 / 4 3 / 0 5 / 0 1 / 1 test threshold 7 1 / 7 2 / 3 3 / 0 5 / 0 1 / 1 language version 6 1 / 6 2 / 3 2 / 3 5 / 0 1 / 0 network rule format 5 1 / 5 2 / 2 2 / 2 4 / 0 2 / 0 data store version 4 1 / 4 3 / 0 4 / 0 5 / 0 2 / 1 backup interval 3 1 / 3 2 / 1 4 / 0 5 / 0 1 / 2 TOTAL 80 10 / 80 19 / 49 25 / 35 49 / 0 10 / 6 d = number of distinct choices born in the item, a = person-days the shared tool gives blocked l/h = legitimate requirements / habits blocked in wall mode ``` ## Diversity and Alignment The totals row shows all four modes at a glance. In wall mode, diversity is **10** — ten items, ten choices — and the shared-tool value is captured **in full**: 80 person-days. In free mode, diversity rises to **49** and the shared tool gives **none of the 80 person-days**. The two modes in between sit at diversity 19 and 25, worth 49 and 35 person-days respectively. The numbers reveal a rule independent of any mode's name: when diversity doubles, the shared tool's value does not halve, it falls far faster. In the `data store version` item, default mode produces four distinct choices and the four-person-day shared-tool value goes to zero; the same happens in `backup interval`. In free mode, every item except `network rule format` produces five distinct choices, because teams with no preference go their own way too. The last column separates what mandate blocks. Wall mode blocks **ten legitimate requirements** and **six habits**. Those ten requirements are spread across four teams and are all choices the work requires: `field`'s base image, `meter reading`'s secret store and network rule format, `billing`'s language version. When mandate blocks these, the team does not go without the work — **it builds a workaround**, and the cost of that workaround is in the next table. ## Guardrail or Wall **PA23 — the costs: every blocked legitimate requirement is 8 person-days, every blocked habit is 1 person-day, and every option after the first on an item is 4 person-days of shared maintenance.** The reason: blocking a habit creates friction, blocking a legitimate requirement creates work; the two cannot be written with the same number. **PA24 — a fifth regime, mixed, computes the net value of all four modes separately for every item and picks the highest; ties favor the freer mode.** ```js // regimes.mjs — five regimes, the gap between guardrail and wall, and the best mode per item import { readFileSync } from "node:fs"; const { ITEM } = JSON.parse(readFileSync("mode.json", "utf8")); // PA23 — costs: every blocked legitimate requirement is 8 person-days (the team builds a workaround), // every blocked habit is 1 person-day (friction), and every option after the first on an item // is 4 person-days of shared maintenance. PA24 — a fifth regime, mixed, computes all four modes' // net value separately for each item and picks the highest; ties favor the freer mode. const LEGITIMATE = 8, HABIT = 1, OPTION = 4; const MODE = { wall: (t) => 1, guardrail: (t) => (t && t.legitimate ? t.option : 1), default: (t) => (t ? t.option : 1), free: (t, i) => (t ? t.option : 100 + i) }; const MODES = ["wall", "guardrail", "default", "free"]; const diversity = (k, x) => new Set(k.preferences.map((t, i) => MODE[x](t, i))).size; const alignment = (k, x) => { const c = diversity(k, x); return c === 1 ? k.shared : c === 2 ? Math.floor(k.shared / 2) : 0; }; const blocked = (k, x, m) => k.preferences.filter((t, i) => t && t.legitimate === m && MODE[x](t, i) !== t.option).length; const net = (k, x) => alignment(k, x) - LEGITIMATE * blocked(k, x, true) - HABIT * blocked(k, x, false) - OPTION * (diversity(k, x) - 1); const best = ITEM.map((k) => { const s = MODES.map((x) => ({ x, n: net(k, x) })); const top = Math.max(...s.map((y) => y.n)); return { ...k, mode: s.filter((y) => y.n === top).pop().x, n: top }; }); const REGIME = [...MODES.map((x) => ({ name: x, mode: () => x })), { name: "mixed", mode: (k) => best.find((y) => y.name === k.name).mode }]; const T = (f) => ITEM.reduce((t, k) => t + f(k), 0); console.log("regime".padEnd(12) + "diversity".padStart(11) + "shared tool".padStart(12) + "useless".padStart(13) + "alignment".padStart(11) + "blocked legit.".padStart(16) + "blocked habit".padStart(15) + "option maint.".padStart(16) + "net".padStart(6)); for (const d of REGIME) { const c = (k) => diversity(k, d.mode(k)); console.log(d.name.padEnd(12) + `${T(c)}`.padStart(11) + `${ITEM.filter((k) => c(k) <= 2).length}/10`.padStart(12) + `${ITEM.filter((k) => c(k) >= 3).length}`.padStart(13) + `${T((k) => alignment(k, d.mode(k)))}`.padStart(11) + `${T((k) => blocked(k, d.mode(k), true))}`.padStart(16) + `${T((k) => blocked(k, d.mode(k), false))}`.padStart(15) + `${OPTION * (T(c) - ITEM.length)}`.padStart(16) + `${T((k) => net(k, d.mode(k)))}`.padStart(6)); } const diff = T((k) => alignment(k, "wall")) - T((k) => alignment(k, "guardrail")); console.log(`\ngap between guardrail and wall: wall blocks 10 legitimate requirements and raises ` + `the shared-tool value by ${diff} person-days — ${(diff / 10).toFixed(1)} person-days per ` + `blocked requirement, while blocking one requirement costs ${LEGITIMATE} person-days`); console.log("best mode per item — " + MODES .map((x) => `${x}: ${best.filter((y) => y.mode === x).length}`).join(", ")); for (const x of MODES) { const g = best.filter((y) => y.mode === x); if (g.length) console.log(` ${x}: ` + g.map((y) => `${y.name} (${y.n})`).join(", ")); } ``` ``` regime diversity shared tool useless alignment blocked legit. blocked habit option maint. net wall 10 10/10 0 80 10 6 0 -6 guardrail 19 9/10 1 49 0 6 36 7 default 25 6/10 4 35 0 0 60 -25 free 49 0/10 10 0 0 0 156 -156 mixed 17 9/10 1 60 2 6 28 10 gap between guardrail and wall: wall blocks 10 legitimate requirements and raises the shared-tool value by 31 person-days — 3.1 person-days per blocked requirement, while blocking one requirement costs 8 person-days best mode per item — wall: 2, guardrail: 5, default: 3, free: 0 wall: base image (3), secret store (2) guardrail: dashboard naming (11), deployment step order (-1), test threshold (-2), data store version (-9), backup interval (-5) default: log format (14), language version (-1), network rule format (-2) ``` Every uniform regime either loses money or barely gains any. Wall gives **−6**, default **−25**, free **−156** person-days; the only uniform regime with a positive number is guardrail (**+7**). The free regime's numbers leave no room for argument: the shared tool becomes useless in **all** ten items, and 156 person-days go to option maintenance alone. The result for default mode is more surprising. It blocks no legitimate requirement and no habit — and yet it is **19 person-days worse than wall**. The reason is in the two middle columns: it drives diversity up to 25, ends the shared tool in four items, and costs 60 person-days of option maintenance. **Blocking nothing is not free.** The gap between guardrail and wall is counted in a single line. By blocking the ten legitimate requirements guardrail allows, wall raises the shared-tool value from 49 to 80, a gain of **31 person-days**. That is **3.1 person-days** per blocked requirement, while the cost of blocking one legitimate requirement is 8 person-days. **Wall pays more than two and a half times what it takes in.** The number of habits the two modes block is the same (6): guardrail grants no exception to habit either. Guardrail's only difference from wall is in legitimate requirements, and in exchange it pays the cost (36 person-days) of letting diversity climb from 10 to 19. The mixed regime decides item by item and comes out highest at **+10**. The split is: wall in two items, guardrail in five, default in three, **free in none**. The two items wall wins are `base image` (11) and `secret store` (10) — two of the items with the highest shared-tool value. In these two, mandate **is worth blocking a legitimate requirement for**, because the shared tool's full value exceeds the cost of blocking. It is not worth it in the remaining eight. Choosing a mode is not a management preference, it is a calculation between an item's shared-tool value and the number of requirements it blocks. ## Summary - Ten items were run in four modes: diversity is 10 in wall, 19 in guardrail, 25 in default, 49 in free; the value the shared tool gives is 80, 49, 35, and 0 person-days respectively. - In free mode the shared tool becomes useless in all ten items; in default mode, in four items; in guardrail, in one; in wall, in none. - Wall blocks ten legitimate requirements and six habits; guardrail blocks the same six habits but blocks none of the legitimate requirements. - The gap wall takes from guardrail is 31 additional person-days of shared-tool value, 3.1 person-days per blocked requirement — below the 8-person-day cost of blocking one requirement. - Net across uniform regimes: wall −6, guardrail +7, default −25, free −156 person-days. Default, which blocks nothing, is 19 person-days worse than wall. - Choosing the best mode per item yields a net of +10: wall in two items, guardrail in five, default in three, free in none. ## Next Step Across four lessons, the platform was measured as a cost calculation, an operating model, a scope, and a mode choice. All four shared one assumption: when a team wants something, **someone on the platform team does it**. Changing a default option in the mode table, entering the path in the scope table, getting a capability in the request table — all of it passed through a person's hands. The next lesson removes that assumption: the same request set is run in a request queue and in a self-service regime; wait time, the platform team's interruptions, and self-service's own cost — the work of writing the interface, misuse, and irreversible operations — are counted.