Mastering Growth: Small Changes, Big Impact!

The Pros Know the Fundamentals Better!

Weekly Edition

Three high‑impact topics (about 90 seconds each) to compound your growth. Plain English, vivid metaphors, practical moves.


1) The Delta Rule: Ship the Smallest Behavior Change

Don’t ship “a feature.” Ship the smallest behavior change that helps a real user. Think in deltas—what specifically will be different after this change?

Why this compounds

  • Lower risk: smaller bets fail smaller.
  • Faster feedback: you learn sooner, steer sooner.
  • Clearer intent: reviewers and stakeholders see the exact promise, not a vague bundle.

Metaphor

  • Moving a sofa through a doorway: rotate and slide—don’t remodel the house. The right micro‑move beats brute force.

How to do it

  1. Name the delta in one sentence
    • “After deploy, search results will show thumbnails for items with images.”
  2. Anchor to one observable signal
    • A metric, log, or screenshot you can point to tomorrow.
  3. Defer everything else
    • Separate “nice” from “necessary.” Park follow‑ups in a short list.
  4. Prove it end‑to‑end, thinly
    • Vertical slice over broad scaffolding. Don’t build the whole kitchen for one sandwich.
  5. Make reversal cheap
    • Flag or toggle the delta. Roll back the behavior, not the world.

Try this today

  • Open your current task. Rewrite it as: “Smallest user‑visible difference + how we’ll see it worked.” If the sentence is long, your delta is too big.

Further reading

  • Kent Beck on small batches and fast feedback [book: Extreme Programming Explained]
  • Accelerate: why smaller batch size speeds delivery [book: Accelerate]
  • Martin Fowler on “Increments” and evolutionary change martinfowler.com

2) Dependency Diet: Your Imports Are Houseguests

Every library, service, or SaaS you rely on is a houseguest. A few are helpful; too many eat your food, clutter your space, and raise your bills.

Why this compounds

  • Fewer surprises: fewer moving parts, fewer sudden breaking changes.
  • Faster upgrades: smaller graph, less pinning pain.
  • Sharper focus: you spend energy on your product, not on shepherding transitive dependencies.

Metaphor

  • Pantry management: staples you trust, labels facing outward, expiry dates visible. Mystery jars lead to bad dinners.

Practices that work

  1. Wrap the outside world
    • Put a tiny “adapter” around any external API. Your code talks to your wrapper, not to “everyone’s” SDK. Swap/upgrade behind the wrapper.
  2. Pin, then review on purpose
    • Lock versions; schedule upgrades on a cadence instead of “surprise Tuesdays.”
  3. Count your transitive chain
    • A lightweight “import bill of materials” (top 10 by fan‑in). Long chains deserve extra caution.
  4. Prefer boring dependencies
    • Pick well‑documented, widely used libraries with slow‑moving APIs. Novelty has a maintenance tax.
  5. Set an eviction policy
    • If a dep causes X incidents or blocks Y upgrades, you replace or remove it. Write the threshold now.

Try this today

  • List your top five external dependencies. For one of them, add a thin wrapper with: inputs, outputs, error shapes, and one integration test that uses a fixture or mock.

Further reading

  • Hyrum’s Law: why implicit contracts bite when deps change hyrumslaw.org
  • Semantic Versioning and its limits in practice semver.org
  • Michael Nygard on stability and bulkheads [book: Release It!]

3) Time and Chance: Make Systems Testable by Freezing Both

Most flaky behavior hides in two places: time and randomness. Treat both as pluggable ingredients, not hardwired facts.

Why this compounds

  • Reliable tests: fewer flakes, faster pipelines, calmer teams.
  • Reproducible incidents: “Freeze the clock, replay the ID stream,” then fix with confidence.
  • Safer refactors: when behavior depends on injectable time/chance, you can change internals without changing outcomes.

Metaphor

  • Movie set lighting: you don’t rely on the sun. You bring lights you can aim, dim, and repeat.

How to do it

  1. Inject a clock
    • Pass clock.now() instead of calling the system clock. In tests, use a frozen or scripted clock.
  2. Inject randomness
    • Pass a rng that can be seeded. Record seeds for failures and incident replays.
  3. Script time windows
    • Define “business day,” “grace period,” and “timeout” in one place. Don’t sprinkle magic numbers.
  4. Separate scheduling from doing
    • A scheduler decides when; a worker does the work. Each is testable in isolation.
  5. Record IDs and outcomes
    • Log correlation IDs, chosen seeds, start/end times. That’s your reproduction recipe.

Try this today

  • Find one place that calls the system clock directly. Replace it with a clock parameter and add a test that advances time in steps to prove the behavior.

Further reading

  • John Ousterhout on making dependencies explicit [book: A Philosophy of Software Design]
  • Fowler on test seams and indirection for isolation martinfowler.com
  • Jepsen analyses on time, randomness, and failure modes jepsen.io

Quick Recap

  • The Delta Rule: ship a crisp, toggleable behavior change, not a bundle.
  • Dependency Diet: wrap, pin, and prune your imports like a tidy pantry.
  • Time and Chance: inject clocks and randomness so tests and incidents are reproducible.

Keep compounding: tiny, teachable moves today create outsized speed, safety, and joy tomorrow.