Skip to content

Engineering judgment

Practical engineering judgment: framing problems, trade-offs, deciding with incomplete information, changing code safely, debugging method and scoping.

22 lessons

Deciding under trade-offs

  1. 1Problem framingMake the missing outcome visible before selecting the means.
  2. 2Trade-off reasoningExplain what each option buys, what it costs, and what would change the choice.
  3. 3Two-way and one-way doorsMatch decision effort to the consequences of going back.
  4. 4Deciding with incomplete informationMake uncertainty visible and choose the next information deliberately.
  5. 5Choosing technology and dependenciesA new tool is a bill you pay every month it runs; count it before you add it.

Modelling data and contracts

  1. 6Data first: model the data, the rest followsModel entities, owners, rules, states and write paths before the API; then make the database refuse any write that breaks a rule.
  2. 7Contract thinking from the caller's sideDesign an interface from its caller's code: name each choice, report errors as next moves, and promise explicitly what callers may rely on.
  3. 8Naming and code clarityName the meaning and the unit; convert in one named place; comment what code cannot say.

Changing code safely

  1. 9Orienting in an unfamiliar codebase fastRun it and read its tests first; let history show where change lands and why; ask only what history cannot say.
  2. 10Refactoring safelyChange how code is built or what it does, never both at once: green refactor steps first, then each behaviour change in its own commit.
  3. 11Working with legacy codePin what it does today, odd results included; change it through seams a slice at a time; learn why odd parts exist before removing them.
  4. 12Testing judgment: confidence per costSpend tests where failure is likely and costly, keep the risky part real, assert what callers see, and see each test fail.

Debugging as a method

  1. 13The debugging methodKeep the failure check stable while experiments shrink the uncertainty.
  2. 14Bisection: binary search on commits, input, config and timeWrite the check, then let halving find where it stopped passing.
  3. 15Fix the class, not the instanceAsk what let the bug be written, and guard the whole class at the highest rung that can see it.

Production mindset

  1. 16Change safety: blast radius, detection, the way backBefore shipping, name the blast radius, the metric already counting, the way back and the exposure limit; roll back before fixing forward.
  2. 17Failure-mode thinking: what breaks at 10x and when X is downWalk every dependency through down, slow, wrong, repeated and ten times the load; decide each one's degraded mode early, and rehearse it.
  3. 18Security mindset: trust boundaries and least privilegeDraw where trust changes, treat every crossing as hostile, and make the server check who may do what, on which object, every time.

Numbers, performance and scope

  1. 19Measure before optimisingSpeed up where the time is: a part's share of the time caps what any fix to it can give, so measure before and after.
  2. 20Scoping under uncertaintyJoin every part with one thin path, add thin slices, spike the biggest unknown, announce a range, and cut scope to keep dates.

People and tools

  1. 21Knowing when and how to ask for helpCount both people's minutes, timebox the dig, and send one question the helper can answer without asking back.
  2. 22Delegate by checkabilityHand the assistant work in proportion to how cheaply you can check it, and name the check that would prove it wrong.