Skip to content

Simple Design Can Save Process

In many projects, process overhead compensates for a design that is too large or too speculative. Cutting smaller can save coordination; external requirements and real dependencies remain.

≈ 10 min readSoftwareProduct

A change board doesn’t measure how risky a change is. It measures how big it was cut. The same goes for the approval round, the design review and the weekly integration meeting: they react to the shape a design gave the work, not to its domain value.

That’s why the usual proposals against too much process start in the wrong place – one more committee, tighter approvals, a rebuilt ticket board. That manages friction instead of getting rid of it. The question that comes before is more fruitful: why does this one change need three teams, two reviews and an approval meeting in the first place? Very often the answer lies in the design, not in the organization. Not always, but often enough that it’s worth looking there first.

Overhead is expensive before it becomes visible#

Before I get to design, it’s worth looking at the bill. In his text on YAGNI (“You Aren’t Gonna Need It”), Martin Fowler neatly broke premature, speculative complexity down into types of cost: there’s build cost – building the feature you don’t need today. There’s delay cost – what you didn’t work on in the actual problem during that same time. There’s carry cost – every line of speculative flexibility has to be carried, understood, tested and worked around from now on. And there’s repair cost when the prebuilt assumption turns out to be wrong.

The point that almost always gets lost in discussions: a large part of these costs is coordination cost. A flexible, configurable design laid out “for later” needs a design review. It needs a config ticket. It crosses team boundaries and therefore needs alignment. That’s why YAGNI isn’t a laziness principle but a design principle – and, incidentally, a process-saving principle. Less prebuilt complexity means less to align on.

A small example I see again and again in variations:

# Over-engineered: a pluggable strategy, a factory, and a config object
# for ONE rule that exists today. This needs a design review, a config
# ticket, and a feature-flag rollout before it ships.
class DiscountEngine:
    def __init__(self, strategy: DiscountStrategy, config: DiscountConfig):
        self.strategy = strategy
        self.config = config

    def apply(self, price: Money, customer: Customer) -> Money:
        return self.strategy.compute(price, customer, self.config)


# YAGNI: the one rule you actually have today. One PR, no coordination,
# no ticket for a config value nobody has asked for yet.
def apply_discount(price: Money, is_returning_customer: bool) -> Money:
    return price * 0.9 if is_returning_customer else price

The lower variant isn’t “sloppy.” It’s honest. It describes exactly the one rule that exists today. And it costs almost nothing to ship – no round through the committee, no flag, no meeting. If a second discount rule comes along tomorrow, I refactor – then, with real information, instead of today on suspicion.

The real lever: the size of the cut#

The discount is the small stage. The big one is the question of how large a change is before it goes live. And this is exactly where the connection lies that I most like to draw out in reviews.

flowchart TB
    A["One large change<br/>crossing three teams"] --> B[Design Review]
    B --> C[Cross-team Ticket]
    C --> D[Merge Conflict]
    D --> E[Change Board]
    E --> F[Coordination Meeting]
    F --> G[Release]

    A2["Same value, cut into three<br/>small independent changes"] --> H["Context A<br/>own pipeline"]
    A2 --> I["Context B<br/>own pipeline"]
    A2 --> J["Context C<br/>own pipeline"]
    H --> K[Release]
    I --> K
    J --> K

The core message of the diagram is simple: coordination effort doesn’t depend on the feature’s value. It depends on the size of the cut and how many team boundaries a cut crosses. A large change that touches three teams creates thick coordination edges – reviews, merge conflicts, change board, alignment rounds. The same domain value, broken down into three small, independent changes, creates almost no cross edges. Each change stays in its own bounded context and goes through its own pipeline.

This isn’t theory. The State of DevOps reports of recent years – the work around Forsgren, Humble and Kim – show the same empirically. High performers work with few active branches, integrate into trunk at least once a day and have no long integration or freeze phases. They replace merge and coordination overhead with small batches. Trunk-Based Development is exactly that: making the cut so small that the elaborate coordination never arises in the first place.

And the part that surprises skeptics: small deployments aren’t riskier but safer. The same data shows that high deployment frequency and short lead time for changes correlate with a lower change fail rate and shorter time to restore. A small cut is easier to understand, easier to review and easier to roll back if something goes wrong. A large cut needs the heavy approval ceremony – because it really has earned it. You build yourself the process that the size forces on you.

When coordination is just a symptom#

A pattern that persists stubbornly in projects: two teams align in a recurring integration meeting because team A provides an endpoint that team B depends on. Every change is discussed in advance, every integration tested together. The process is real – but it only compensates for the fact that nobody made the expectation between the teams explicit.

Consumer-Driven Contracts turn this around. The consumer describes exactly what it needs – no more. The provider verifies this contract in its own pipeline, independently. The alignment meeting disappears because the alignment lives in the code:

// The consumer declares only what it actually needs. No cross-team
// integration meeting, no shared end-to-end test suite to schedule.
pact
  .given("customer 42 exists")
  .uponReceiving("a request for the customer name")
  .withRequest({ method: "GET", path: "/customers/42" })
  .willRespondWith({
    status: 200,
    body: { name: like("Ada") },
  });

// The provider replays this contract in ITS OWN pipeline and fails fast
// if it ever breaks the expectation — independently, no meeting required.

Tools like Pact have made this practical for a few years now. The effect is the same as with the small cut: a piece of coordination that used to exist as a meeting becomes an executable specification – and the process around it is no longer needed.

Governance without a committee#

The same pattern applies at the architecture level. Many heavyweight governance processes – the architecture committee that signs off on every change – exist because nobody found a more lightweight way to enforce architecture rules. Neal Ford and Rebecca Parsons coined a nice term for the alternative: fitness functions. Instead of designing big once up front and then guarding it through a committee, you formulate the architecture goals as automatically checkable rules in the deployment pipeline.

# Architecture rules as executable guardrails in the pipeline,
# not as a slide reviewed once a quarter by a committee.
fitness_functions:
  - name: modules_stay_decoupled
    rule: "no cyclic dependencies between packages"
  - name: p95_latency_budget
    threshold_ms: 300
  - name: public_api_is_stable
    rule: "no breaking change without a new version"

If the rule is violated, the build turns red – immediately, traceably, the same for everyone. That doesn’t replace architecture work; it replaces the ritual you otherwise use to enforce it. Related to this are Fowler’s ideas of “Sacrificial Architecture” and “MonolithFirst”: build simply and, if necessary, disposably at first, and only bring in complexity when reality forces it. Evolutionary architecture is the consistent refusal to pay process overhead for a future you don’t know yet.

Where the thesis reaches its limit#

The counterargument is justified. Three honest caveats, so that a good heuristic doesn’t turn into an ideology.

First: simple isn’t the same as simplistic. YAGNI applies to speculative features and premature flexibility – not to internal quality. “We’ll leave out the tests and the design, then we’ll be faster” is the misreading Fowler explicitly writes against. The difference is the one between accidental and essential complexity that Brooks already drew. Less speculative structure: yes. Less care in the core: no. The small discount function from above needs its test just as much as the big engine – just exactly one, for the one rule that exists.

Second: overhead isn’t always the design’s fault. Compliance requirements are real. Regulatory gates are real. Real dependencies between teams that can’t be cut away are real. That’s why it deliberately says “often” above and not “always.” It’s not about abolishing every process step. It’s about questioning it: are you compensating for a requirement from outside right now – or for a complexity we built ourselves?

Third: a smaller cut can also just shift complexity. Turning one module into two services trades code coupling for distributed coupling and network. That’s sometimes right, but it’s never free. That’s exactly why contract tests are the replacement for the full end-to-end integration circus – and exactly why Fowler’s “MicroservicePremium” is worth remembering: you have to earn distribution; it’s not a default. If you cut small without placing the cut along real domain boundaries, you end up with more coordination, not less.

How I approach it concretely#

The order that has proven itself doesn’t start with the process.

flowchart LR
    A["Spot the heavy<br/>process step"] --> B["Ask: what complexity<br/>is it compensating?"]
    B --> C["Cut the change<br/>smaller"]
    C --> D["Make the expectation<br/>explicit as a contract"]
    D --> E["Turn the gate into a<br/>fitness function"]
    E --> F["Drop the step<br/>that is now redundant"]

First I look for the most expensive process step – the meeting that annoys everyone, the approval that always blocks. Then I don’t ask “how do we make it more efficient” but “what complexity is it absorbing.” Most of the time we find a cut that is too large behind it, an unspoken expectation or governance nobody has automated. Then we cut smaller, make the expectation explicit as a contract, cast the gate into a fitness function – and drop the step that no longer absorbs anything, without replacement.

The result is rarely spectacular and almost always noticeable: shorter cycles, because less is waiting for approvals. Less friction, because less has to be aligned across team boundaries. Higher quality, because small changes are easier to check and easier to roll back if something goes wrong. Simple and elegant instead of process overhead – that falls out as a by-product of better design and isn’t a cost-cutting measure.

Conclusion#

Process is expensive, and usually it’s expensive for a good reason: it absorbs friction that really exists. But the more interesting question is almost never how to make the process more efficient. It’s why the friction arises in the first place. Very often the answer is a design that is too large, too speculative or too implicit.

Cutting smaller beats coordinating more. Explicit contracts beat recurring alignment. Automated guardrails beat committees. And YAGNI beats any flexibility you build today and work around tomorrow. This isn’t an invitation to sloppiness – internal quality remains non-negotiable. It’s an invitation not to take process overhead as a law of nature but to read it as a symptom. If you make the problem small in the right place, you don’t need the heavy machinery around it in the first place.

Where the process compensates for self-built complexity, a simpler design can actually make it superfluous. Where regulation, operations or real team dependencies are the cause, that calculation remains open. To me, exactly this distinction matters more than the blanket demand for less process.

Further reading#

Revised and translated from German with the help of AI.