Standardization and Autonomy Balance

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.

// 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.

// 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.