There’s a decision I made years ago that I still think about.
I don’t bring it up much. It’s not a great look for someone who sells technical judgment for a living.
We were building a proof of concept. New product, real ambition, the kind of thing you pour yourself into before anyone’s watching.
I needed a database.
And there was this new thing everyone was excited about. Realtime, slick, no servers to babysit, data syncing across clients like magic. It felt like the future.
So I picked it.
Not because it fit the problem. Because it was exciting.
Here’s the part I didn’t want to admit at the time. Most of our data wasn’t realtime data. It was relational. Records that related to other records. The kind of thing a boring SQL database has handled beautifully for forty years.
But I’d already fallen for the shiny one. So we forced it. We poured structured, relational data into a tool built for something else entirely.
For a while it worked. Demos looked great.
Then we tried to actually use the data.
We couldn’t run a simple count. Couldn’t aggregate. Couldn’t paginate properly. The basic things you take for granted, the things a relational database does without you even thinking about it, were suddenly hard. Or impossible. Or doable only through ugly workarounds that created their own problems down the line.
We paid for that choice for a long time. Rework. Technical debt. Hours I will never get back untangling something that never should have been tangled in the first place.
And the worst part wasn’t the lost time.
It was knowing I knew better.
I’d been building software for years by then. I had the experience to make the right call. I had probably made the right call a hundred times before on other projects.
But experience doesn’t make you immune to wanting the new thing.
If anything it can make it worse. You trust yourself enough to override the quiet voice saying “this doesn’t actually fit.”
The boring choice was sitting right there the whole time. Proven. Unglamorous. It would have saved me years.
I didn’t pick it. Precisely because it was boring.
But here’s the part I’m actually proud of.
We didn’t just live with the mess. We didn’t shrug and route around it forever.
We went all in on fixing it. My team and I tore the thing down to the studs, mapped what actually belonged where, and rebuilt it the right way. The relational data went into a relational database, where it should have been from day one. The realtime pieces, the ones that genuinely needed to be realtime, stayed where they made sense.
A hybrid. The boring tool and the shiny tool, each doing the exact job it was built for.
It worked. And it kept working.
So here’s what I’d actually say to you, if you’re building something right now.
Excitement is not a reason. When you’re choosing your stack, your model, your next big architectural bet, the question is never “is this cool.” It’s “does this fit the problem in front of me.”
Pick the boring thing when boring is what the job needs. Save the new thing for when it earns its place.
And if you’ve already made the wrong call, and most of us have, it is not the end. Own it. Go all in. Fix it properly.
The mistake was never the thing that could sink me.
Pretending I hadn’t made it would have been.
