There’s a moment, usually early in the morning, when the garden is still damp and quiet where I just stop and look down.
It’s not dramatic. No music swells. No monologue. Just me, standing barefoot on soil that didn’t used to be soil, staring at a space that used to be a mess of weeds, gravel, and compaction. Now it grows food. Now it holds structure.
But it didn’t get there by accident. Like anything else worth building, it runs on a stack.
Not the kind made of APIs or microservices, but it’s layered just the same. And the more time I spend growing things, the more I realise how much it resembles the way I think about technology, systems, and autonomy.
the First Layer, Foundation & Infrastructure
The base layer is simple: dirt.
Except it’s not. It’s reclaimed, remixed, and restructured over time. It started as hard-packed subsoil and construction debris. You have to break it, sift it, amend it over and over until it became something more like soil and less like resistance.
That’s the infrastructure layer: it supports everything, but it took real work to make it viable. In tech, we talk about “legacy code” or “tech debt” but in gardening, it’s more like legacy damage. Someone compacted this ground years ago, and you are still fixing it.
Now I see that every system I’ve ever built was sitting on a foundation like this. Sometimes you inherit it. Sometimes you make it. Either way, it matters.
The Second Layer, Substrate & Interfaces
Above that is the growing medium, the layer that actually interacts with roots.
It’s where compost meets clay, mulch breaks down, moisture balances. It’s dynamic. Alive. This is where the roots negotiate their conditions. Not too wet. Not too dry. Not too dense.
Think of it like an API between biology and environment. The interface matters more than the core.
Just like in software, if your interface is hostile, bad UX, confusing endpoints, unclear error states, then nothing thrives. The data (or the roots) don’t care about your intentions. They care about access, clarity, responsiveness.
Layer 3: Operations Layer
This is where the human comes in.
Me, out there in the early dark, checking on drainage, adjusting watering schedules, swapping one plant out for another based on observed stress. The ops layer.
It’s imperfect. It’s guesswork sometimes. But it’s informed by real observation, iteration, and pattern recognition.
This is where I think most people burn out, whether in gardens or systems. They want a set-and-forget model. But nature and infrastructure don’t work that way. You don’t “finish” building. You maintain. You adapt. You answer weird errors with weird fixes and try again.
Layer 4: Output
What does the system produce?
In a garden, it’s food, colour, pollinators, carbon drawdown, maybe even peace. In tech, it’s service delivery. Or maybe it’s privacy. Or uptime. Or reliability in a hostile environment.
The garden reminds me: if the output doesn’t match the intent, it’s not always the top layer’s fault. The roots might be wrong. The soil might be dry. The interface might be too tight for the roots to breathe.
Systems don’t fail at the surface. They fail quietly, several layers down.
Systems as Living Things
The more I garden, the more I understand that every system I build, digital or not, needs to be treated as a living thing.
It needs space to breathe. Feedback loops. Time to settle. It needs inputs, maintenance, and protection from entropy. Most of all, it needs to be observed without judgment. Because systems are not perfect. They’re not supposed to be.
They’re supposed to work, over time, in context.
The garden works. Not because it’s optimised, but because it’s layered. Because every layer talks to the next. Because the stack beneath my feet has been tuned by hand, season by season, mistake by mistake.
I stand on it every day. And it holds.
Part of my Garden as System series.