Skip to content

System Architecture

The architecture problem I’m most often called in on is self-inflicted complexity. A system that should be straightforward has been carved into microservices, message queues, and layers of abstraction it never needed, and now it’s slow to change, hard to reason about, and breaks in ways nobody can trace. Good architecture is the discipline of keeping a system simple enough to change — and most of the architecture work I do is removing complexity that was added to look modern, not solve a real problem. That restraint is the skill, and it’s rarer than it should be.

The problems I solve here

The first is the system that’s been over-architected. Someone built for a scale that never arrived — distributed services, an event bus, elaborate abstraction — to run a workload a single well-built application would have handled comfortably. Now every change touches five services, local development is a nightmare, and failures hide in the gaps between components. I’m brought in to find the simple system trying to get out, and to chart the way back to it without breaking the business.

The second is the architecture decision that’s about to be made, where the cost lands months later when it’s hard to undo. Should this be one system or several? Build or buy this piece? What’s the data model? These are the calls that quietly decide whether the next two years are cheap or expensive, and they’re easy to get wrong under the pressure to look like a “proper” architecture. I’m hired to make them with someone who’s lived with the consequences of both answers.

The third is the system that’s grown organically into something no one fully understands. Not over-engineered on purpose — just accreted, decision by decision, until the architecture is whatever happened rather than anything chosen. The work is to map what’s actually there, find where the real fragility lives, and bring deliberate shape back to it.

How I think about system architecture

The first principle is that simplicity is the senior move, not the junior one. Reaching for microservices, queues, and elaborate patterns is easy and looks impressive; building the simplest system that genuinely solves the problem, and resisting everything that doesn’t earn its place, is harder and far more valuable. Complexity is a cost you pay every single day you live with the system — in every change, every onboarding, every incident. The best architecture is usually the most boring one that works, and most teams discover this only after paying for the exciting version.

The second is that you architect for the problem you have, not the one you imagine. The classic expensive mistake is building for a scale you don’t have and may never reach, paying the full cost of that complexity now against a benefit that may never arrive. The right move is the simplest thing that solves today’s real problem, designed so it can evolve when — and only when — the bigger problem actually shows up. A simple system you can change beats a complex one you built for a future that didn’t come.

The third is that the data model is the part you can’t cheaply undo, so it gets the real care. Frameworks, services, deployment — most of it is reversible. The shape of your data, once a business is running on it, is the hardest and most expensive thing to change. I spend my architectural attention there first and keep everything above it simple enough that changing course stays affordable. And it points back to ownership: a system you own and understand can be reshaped on your terms; one assembled from rented pieces you don’t control can only be reshaped as far as the vendors allow.

How I’d actually do it

Faced with a system buckling under its own architecture, I wouldn’t propose a grand redesign — that’s just more complexity arriving later. I’d find the simplest shape that solves the actual problem, identify the few decisions causing most of the pain, and move toward that incrementally, keeping the business running the whole way. Often the destination is unglamorous: collapse three services that didn’t need to be separate, drop the queue that was solving a problem you don’t have, get the data model right. Boring, legible, and changeable.

When I’m designing something new, I build to an MVP architecture: the smallest system that solves today’s problem, with the seams placed where the system is genuinely likely to grow, so it can evolve without a rewrite — but not built out for that growth before it’s real. That’s the balance senior architecture is actually about. Not anticipating everything, and not painting yourself into a corner either. Owned, understood, and simple enough to change.

Where this connects

This is one of the specialisms I’m hired for. Architecture decisions rest on getting the databases and data model right — that’s the load-bearing call — and they shape whether you reach for owned API integrations or a sprawl of rented connectors to hold the system together. The engagement this most directly powers is an architecture review when you need an honest read on whether what you’ve built will hold, or a fractional CTO arrangement when the architecture calls keep coming and you need someone senior owning them.

When you need a team instead

Designing and running a genuinely large-scale system — many services, real scale, continuous operations — is team work, and the complexity there can be warranted. That’s my agency, Digital Royalty, with the crew to build and run it. My lane is the senior architecture judgement: what to build, what to simplify, where the real risk sits. I’ll tell you honestly when your system has genuinely outgrown one person’s reach.

Who this isn’t for

If you want an architecture that looks impressive on a diagram more than it serves the business, I’m not your fit — I’ll argue for the boring version that you can actually live with. I’m worth hiring when you want a system simple enough to change, and the judgement to keep it that way.

Talk to me

If your system has become hard to change, or you’re about to make an architecture call you can’t easily undo, tell me about your problem and I’ll tell you the simplest shape that solves it.