Most of my projects didn’t actually fail.
They just never shipped.

Which is worse.

Looking back, the reason was simple: I was over-engineering everything.

In my head, every project had to be “scalable” before I even had a user. Every function had to be “clean.” Every decision had to be “future-proof.”

And most of the time, nothing shipped.

What I Used to Do

I used to spend hours or weeks designing things that didn’t matter yet.

Features nobody asked for. Components that could handle five different use cases. Folder structures that felt “right.” Abstractions for code that might be reused someday.

It looked smart. It felt like progress at the time.

But it slowed everything down.

And the worst part? Most of it never got used.

The edge cases didn’t happen. The reusable parts were used once. The “future-proof” decisions got rewritten anyway.

Eventually, I got tired of it.

What Changed

So I stopped overthinking. I just started building.

If I need a schema, I design it for the current feature. If it needs to change later, I change it later. Migrations aren’t a big deal.

If two components are slightly different, I duplicate. When the pattern becomes obvious, then I refactor.

If I’m not sure something will be reused, I don’t abstract it yet. Writing it twice is cheaper than guessing wrong.

Same with side projects.

I used to think about everything from day one—auth, payments, analytics, dashboards—before anyone even cared about the core feature.

Now I ship the simplest version possible.

Because over-engineering was never really about code.

It was about avoiding risk.

Thinking feels safe. Planning feels productive. But shipping something simple—something that might be wrong—that’s uncomfortable.

So I used to hide behind complexity.

What I Do Now

Now I optimize for something else: momentum.

Build the simplest thing that works. Ship it. Fix what breaks. Improve what people actually use.

Everything else can wait.

I still care about clean code. I still refactor. I still think about scale.

Just not on day one.

Because the code that matters is the code that exists.