Skip to content
Writing

8 June 2026

Simplicity Is the Senior Move

Complexity usually signals inexperience dressed up as sophistication. The senior engineer reaches for the simplest thing that solves the real problem. Here's why.

The simplest thing that solves the real problem is almost always the right answer, and reaching for it is a senior signal — not a junior one. The industry usually has this backwards. It treats elaborate architecture, layers of abstraction, and a stack of clever moving parts as evidence of skill, and treats the plain, obvious solution as something you’d be slightly embarrassed to have proposed. I think that’s exactly inverted. Complexity is usually inexperience wearing a costume. Simplicity, the hard kind that comes from actually understanding the problem, is what experience eventually produces.

That’s the argument. It’s worth making because the wrong instinct here is expensive in a way that compounds: every needless layer you add is something to build, something to understand, something to maintain, and something to break, forever. Choosing simple isn’t choosing less. It’s choosing to pay attention to what the problem actually requires instead of what would look impressive in a diagram.

Why complex reads as smart, and why it’s a trap

The default belief is that the sophisticated solution is the good one. If a system has many parts, careful abstractions, and the current fashionable architecture, it looks like serious engineering. If it’s a few straightforward pieces doing the obvious thing, it looks like someone didn’t try very hard. So people add — patterns, layers, services, indirection — partly to solve problems and partly to signal that they’re capable of handling complexity.

The trap is that complexity is easy to add and almost impossible to take back out. Anyone can make a system more elaborate; that’s the cheap direction. Making it simpler while it still does the job is the hard direction, because it requires understanding the problem well enough to know what’s actually load-bearing and what’s just there. The elaborate solution often isn’t evidence that the problem was hard. It’s evidence that the person didn’t yet understand it well enough to make it small. Early on, you reach for complexity because you can’t see the simple path. Later, you reach for simplicity because you finally can — and because you’ve personally maintained enough overcomplicated systems to know what they cost.

Complexity is a cost you pay forever

Every piece you add to a system is a permanent liability, not a one-time decision. It has to be built, then understood by everyone who touches the system after you, then maintained as everything around it shifts, and it’s one more thing that can fail in a way that’s hard to trace. A clever architecture with seven interacting parts isn’t seven times the work of a simple one — it’s worse, because the cost is in the interactions, and those multiply.

This is why “we might need it later” is such a dangerous phrase. It justifies paying a real cost now — more to build, more to carry, more surface for bugs — against a benefit that’s hypothetical and usually never arrives. You build the flexible, generalised, future-proof version, and the future shows up wanting something you didn’t predict, so now you have both the complexity you built for the wrong guess and the new work. Build the simple thing that solves today’s actual problem, and if the future genuinely needs more, you’ll know what it needs and you’ll add it then, from a smaller and clearer starting point. Simple isn’t a bet against the future. It’s a refusal to pay today for a guess about it.

Simple is not the same as easy, or thin

I want to be precise, because “keep it simple” gets misread as “do the lazy thing” and that’s not the argument at all. Simple is hard. The lazy solution and the simple solution often look superficially alike — both are small — but they come from opposite places. The lazy one is small because the person stopped thinking. The simple one is small because the person thought hard enough to find what the problem actually needed and threw out everything that wasn’t that.

You can tell them apart by what happens under pressure. The lazy-small solution falls over the moment reality touches it, because the thinking that should have gone into it didn’t. The genuinely-simple solution holds, because the complexity the problem really has was handled — it just wasn’t padded with complexity the problem didn’t have. Simple means no unnecessary parts. It does not mean missing the parts that matter. Getting that distinction right is most of the skill.

Where more machinery actually earns its place

There’s a real version of this objection and I’ll concede it cleanly: sometimes the problem genuinely is complex, and matching it requires real architecture. Some systems carry load, regulation, scale, or failure modes where the elaborate solution isn’t ceremony — it’s the minimum that the problem honestly demands. Building a toy where you needed a real distributed system is just the lazy-small failure wearing different clothes.

So the rule isn’t “always smaller.” It’s “match the solution to the real shape of the problem, and not a millimetre more.” The test is whether every piece of complexity is doing work the problem actually requires. If you can take a part out and the real requirements are still met, it was ceremony and it should go. If you can’t, it stays, and adding it was the senior call. Simplicity isn’t a cap on sophistication. It’s the discipline of spending sophistication only where the problem earns it.

What this means for you

When you’re handed a proposal — for an architecture, a rebuild, a new platform — the question to ask isn’t whether it looks impressive. It’s whether every part of it is solving a problem you actually have. Make whoever’s proposing it justify each piece against a real requirement, not a hypothetical one and not “best practice” in the abstract. The good engineer will welcome that question, because the simplicity is the point and they can show you the reasoning. The one selling you complexity for its own sake will reach for “you’ll need it at scale” and won’t be able to tell you when, or why, or what it costs to carry until then.

And underneath the simplicity argument is the same thing the rest of my writing keeps returning to: the simplest system that solves your real problem is also the one you can most easily own, understand, and build on. Complexity you don’t need is also leverage you don’t get.

This is one of my essays — what “MVP” gets wrong is the same discipline pointed at scope instead of architecture, and why most internal software should be built, not bought is what becomes possible once you’ve kept the thing small enough to own. If you suspect your own system has complexity it didn’t need, an architecture review is the honest read on what’s load-bearing and what isn’t.

If something you’ve built feels more complicated than the problem deserves and you want a straight second opinion, tell me about it. And if untangling it turns out to be a long programme of work that needs a team, that’s what my agency, Digital Royalty, is for.