From piece of pie to whole pie

I crashed my first website with an upvote button.

This was years ago. I’d spent two, maybe three months building a music discovery site on WordPress. It was my first proper startup project and I was doing everything I could myself. The frontend was all me - HTML, CSS, the visual layer, the stuff I loved. But the backend? PHP? The actual logic that made things work? That wasn’t my world. I didn’t have those skills yet and if I’m being honest, I didn’t really want them. The code was the ugly bit. I was a designer. I wanted to make things look good and feel right, not wrestle with server-side languages.

But I was stubborn. So I hacked it together anyway. Found plugins, stitched them in, got things roughly working through a combination of tutorials and sheer determination. I built an upvote feature so users could vote on tracks. Felt great. Looked great. Worked great - right up until more than about twenty people used it at the same time, at which point it absolutely obliterated the database.

The upvote plugin was hammering the database with a write operation on every single click. No caching. No rate limiting. No batching. Just raw, unoptimised queries firing into MySQL like a machine gun. The site would crawl to a halt and then just fall over completely.

Same story with the view counter. We’d built a YouTube-style play count into each track page, and it was querying the database on every single page load. Every view, another read. Every read, another nail in the coffin. Any time the site got a spike of traffic - which was the whole point of building it - the traffic itself would kill it.

I remember sitting there watching the site go down for the third time in a week and having this very specific, very uncomfortable realisation: I am not self-sufficient. I can design this thing beautifully. I can build the frontend. I can make it feel right. But I cannot, on my own, make it actually work at scale. I need someone else.

That feeling stuck with me for a long time.

The dependency years

If you’re a designer or a non-technical founder, you know this feeling intimately. That specific frustration of having a complete vision in your head - knowing exactly what you want to build, how it should look, how it should behave, how users should move through it - and being physically unable to bring it to life without someone else writing the code.

It’s not that I didn’t understand development. I did. I understood architecture. I understood how systems talked to each other. I could think through data models and API structures and user flows with genuine depth. I loved the problem-solving, the logic puzzles, the architectural building blocks of how software fits together. I was a tinkerer to my core. I’d pull things apart just to understand how they worked.

The bit I couldn’t do - the bit I didn’t care for - was actually writing the code itself. The syntax. The semicolons. The debugging of mysterious errors at midnight. The gap between understanding what needed to happen and being able to make it happen in a programming language was the bottleneck that defined my career for over a decade.

So I did what every designer in my position does. I relied on developers. Good ones, when I could find and afford them. Whoever I could get, when I couldn’t. And there’s nothing wrong with collaboration - I’m not arguing for some solo-founder fantasy where one person does literally everything. But the dependency created real friction. Every idea had to go through a translation layer. Every change had a lead time. Every “can we just try this?” came with a cost estimate and a timeline.

The worst part wasn’t the money or the time. It was the loss of creative momentum. When you’re designing something and you hit a flow state and you can see exactly what needs to happen next - and then you have to stop and write a brief and wait three days for someone else to build it - you lose something. That thread of creative energy snaps. And by the time the build comes back, you’ve moved on mentally. The iteration suffers.

I spent years living in that gap. Able to see the whole pie but only ever owning a slice of it.

The stepping stones

The tools kept getting better, though. Slowly at first, then all at once.

WordPress was the first step. For all its limitations, it was the thing that made me believe a non-developer could ship a real product. The plugin ecosystem, the themes, the community - it democratised web building in a way that hadn’t existed before. It got me 60% of the way there. The remaining 40% - the custom logic, the performance, the things that made a product genuinely yours rather than a dressed-up template - still needed a developer.

Then came Webflow. Webflow was a revelation. Proper visual development. Real CSS under the hood, not drag-and-drop compromises. I could build frontends that were genuinely production-quality without writing a line of code. The design-to-live gap collapsed. For the first time in my career, the thing I built in the design tool was the thing that shipped. No handoff. No “the developer interpreted it differently.” What I made was what users got.

But Webflow was still just the frontend. The moment you needed real logic - user authentication, database operations, dynamic content based on conditions, anything that required a backend - you were back to needing help.

That’s where Xano came in. Xano was a no-code backend builder, and when I paired it with Webflow, something clicked. I had the frontend in Webflow and the backend logic in Xano, and for the first time I could build genuinely functional products end to end. APIs, database operations, conditional logic, authentication - all without writing traditional code. I could finally see the whole picture and build the whole picture myself.

I don’t think I spent more than a year with Xano. Because then Supabase and AI showed up at roughly the same time, and the game changed so fundamentally that everything before it started to feel like a warmup.

The inversion

Here’s what happened, and I think this is the most important shift in my entire career as a builder.

The code stopped being the hard part.

Read that again, because if you’re a designer or a product person or a non-technical founder, this sentence should make your ears prick up. For fifteen years, code was the wall. Code was the thing I couldn’t do, the thing I needed other people for, the thing that stood between my vision and a shipped product.

Now? With AI coding tools, with Supabase handling the database and auth layer, with the entire landscape of developer tooling that’s emerged in the last two years - the code is the easy bit. I can describe what I want and it appears. I can debug by explaining the problem in plain English. I can scaffold entire features in minutes and refine them in hours. The syntax, the semicolons, the mysterious midnight errors - AI handles all of that.

What AI can’t do is the stuff I’ve spent my whole career getting good at. Understanding users. Designing systems. Thinking through architecture. Knowing how a product should feel. Making opinionated decisions about what to build and what to leave out. Seeing the whole picture and making sure every piece serves the overall experience.

The skills that used to be “nice to have on top of the real work of coding” are now the actual hard part. The engineering thinking, the problem solving, the product instinct, the design sensibility - that’s where the value lives. The code is just the output. And the output is now the cheap, fast, abundant part of the equation.

For someone like me - a designer who always understood systems but couldn’t write the code - this is the golden era. I am genuinely, absurdly self-sufficient in a way that would have been unthinkable five years ago. I can go from idea to architecture to design to working product without needing anyone else to bridge the gaps.

The whole pie. Not a slice. The whole thing.

What self-sufficiency actually looks like

I want to be specific about this because it sounds like hype if I leave it abstract.

At Reboxed right now, I’m building our merchant portal, our internal ops platform, our middleware layer, and various automation scripts. I’m designing the UX, defining the architecture, writing the code (with AI), and deploying to production. One person. Not because I’m some genius polymath, but because the tools have collapsed the distance between understanding what needs to be built and actually building it.

Supabase gives me a production-grade database, authentication, real-time subscriptions, and edge functions without me having to manage infrastructure. AI gives me the code I can’t write from memory. My years of design and product experience give me the judgment to know what to build and how it should work. The combination is unreasonably powerful.

Am I building things as elegantly as a senior full-stack engineer would? Probably not. Are there patterns and optimisations I’m missing that someone with a computer science degree would catch? Almost certainly. But I’m building things that work, that scale for our needs, that our team uses every day, and that I can iterate on in real time without waiting for anyone.

That trade-off - slightly less elegant code in exchange for complete creative and operational control - is one I’ll make every single day.

The tinkerer’s era

This is what I keep coming back to. This era doesn’t belong to the coders. It doesn’t belong to the engineers. It doesn’t even belong to the designers, strictly speaking.

It belongs to the tinkerers.

The people who’ve always been curious about how things work. Who pull products apart to understand the architecture. Who think in systems and user flows and feedback loops. Who have opinions about how software should feel, not just how it should function. The people who always had the vision and the understanding but were locked out of the execution.

The lock is gone now. The door is wide open.

If you’re a designer who’s spent years frustrated by the dependency on developers - this is your moment. Not because developers don’t matter. They absolutely do, and for genuinely complex engineering challenges you still need deep technical expertise. But for the vast majority of product building - the kind of building that most startups and most businesses actually need - the tinkerer with AI tools and modern infrastructure can now go from idea to production solo.

I think back to that upvote button that crashed my music site. The kid who built that - who understood exactly what he wanted to create but couldn’t stop the database from falling over - would lose his mind if he could see what I’m building now. Same brain. Same curiosity. Same love for pulling things apart and putting them back together. Just better tools.

The code was never the part I cared about. It was always the thing I had to get through to reach the thing I actually wanted to make. Now I barely have to think about it. The thinking, the designing, the solving - that’s where I live. And for the first time in my career, that’s enough.

Whole pie. Finally.