Beware the wantre-cto

Software development is wonderful because you can build anything.

The tools are free. The tutorials are endless.

You can ship something to the entire world from your bedroom.

The problem is most developers never do.

If you are NOT a non-tech co-founder thinking about hiring a technical partner - you might want to skip this. Developers might be offended.

The game plan of so many folks who call themselves "senior developers" or "tech leads" is to:

• Complete tickets assigned to them
• Follow architectural decisions made by others
• Collect years of "experience" without ever shipping their own thing

They have impressive resumes. They speak fluently about microservices and system design. They'll argue passionately about tabs vs spaces, about which ORM is best, about whether you should use Kubernetes.

But they've never registered a domain and put something on it that works.

When I was hiring developers in India, I kept meeting candidates with "10+ years experience" on their resumes. Impressive titles. Great companies.

But when I asked "What have you built on your own?" - silence.

How is it possible to spend a decade in software and have nothing to show for it online?

They've never configured DNS. Never set up a payment processor. Never woken up at 3am because their thing was down and it was their problem.

I'm not judging

These people can be great employees. Great architects even. They can mentor juniors and thrive in a corporate setting.

Just don't partner with them on a bootstrapped SaaS.

Let's be honest: they're spoiled by a nice paycheck and infrastructure given to them. They can't do "startup mode" anymore.

They've never made hard calls about what to build and what to skip when time is ticking. They'll advocate for "doing it right" because they've never experienced the cost of that when you're burning your own money.

Here's the kicker:

• Overcomplicate your employer's codebase: someone else cleans it up, or you switch jobs.
• Overcomplicate your own project: you eat it. Or worse: customers complain (if you manage to sell anything).

Wantre-CTOs have never held stakes. No equity. No ownership. No skin in the game. Just a salary that shows up whether they ship or not.

The Peter Principle

And then some of these developers become "CTOs."

God help you if you hire one as a first employee (I imagine you are a non-tech co-founder here).

They have the title but they can't code anymore. They'll spend their days in meetings talking about "strategy" while your actual builders are drowning. They'll hire consultants instead of making decisions. They'll create documentation nobody reads instead of products people use.

They can't evaluate developers because they haven't written production code in years. They can't estimate timelines because they've forgotten what building feels like.

A real CTO should have something to show for themselves. Not a resume full of companies. Not impressive LinkedIn titles. Something online. Something that works. Something they built and shipped and maintained.

If this is you

You can fix it.

Build something small. Put it online. Make it work.

Not a to-do app tutorial. Something that solves a real problem, even if it's just your own.

Deploy it yourself. Buy the domain. Set up the hosting. Configure the database. Do the boring stuff you've always let someone else handle.

Then maintain it. Experience what it's like when your architecture decisions haunt you six months later.

Get one user who isn't your friend. Get one person to pay you $5.

This will teach you more than another decade of working on other people's projects.

You'll learn what actually matters. You'll develop taste. You'll understand why shipping beats perfection.

The developers who become great technical leaders all have this in common: they've built things. They've shipped. They've felt the pain.

The wantre-CTOs just talk about it.

Don't be a wantre-CTO.

Have you worked with one? What was the red flag you missed?