How Not to Hire: Lessons From My Self-Inflicted Headache

It’s 11 PM on a Sunday.
Most people are watching Netflix, getting ready for bed.
Me? I’m staring at a codebase that feels like it was assembled during a weekend hackathon by people who didn’t plan on showing up Monday.

Every file I open unravels into another mess.
Every “solution” turns into three new problems.
And here’s the cruel part: this isn’t my mess — but I am the one cleaning it.

Why?
Because I ignored red flags. Because I trusted the wrong people. Because I hired wrong.

The First Engineer: Trust Given, Trust Burned

He was a former colleague. We’d worked in the same company before — me as a Tech Lead, him in another team. Later, we ended up as teammates in another gig.

I’d seen enough to know his work wasn’t flawless. He had quirks. He needed handholding. He could be a burden.
But I told myself:

“Maybe this time will be different. Maybe he’s improved.”

It wasn’t.

I gave him the keys to the suite. I was supposed to architect the system, but he said he’d do it. I let him.

I asked for documentation. He said we didn’t need it.
Red flag. I still trusted him.

I pushed for coding conventions, linters, proper structure. He ignored it.

I asked for specs. I got minimal, flaky, barely functional tests. Eventually, he pushed to just drop specs entirely. And then someone in my ear said,

“Just trust the team.”

So I did.
I let go.
And that’s when pandemonium broke loose.

The Second Engineer: Willing, But Out of Depth

She joined at the same time.
On paper, a “senior.”
Her code begged otherwise.

But here’s the thing — I liked her. She was willing. She was giving. She genuinely wanted to try. But she worked slow, and needed a lot of guidance. Guidance I could have given… but I delegated it to the first engineer.

And if your lead is rotten, no amount of willingness can save the outcome.

How It All Fell Apart

What we ended up with wasn’t a product.
It was an unstable tower of tech debt held together by hope and duct tape.
No architecture discipline. No consistent code style. No reliable test suite.

It wasn’t just technical debt — it was technical bankruptcy.

And worse? My name is now tied to it.
Because when you’re the one fixing it, people don’t care who built it. They just know you’re the one holding the bag now.

The Red Flags I Ignored

I’m not sharing this just to vent. I’m sharing it because if you ignore these, you will end up in my seat at 11 PM on a Sunday.

1. History repeats itself.

If someone was a burden before, they’ll likely be a burden again. Hope is not a hiring strategy.

2. Friendship ≠ competence.

Being likable or having history doesn’t mean they can lead. Liking someone is not a replacement for skill.

3. A bad lead poisons the team.

If your lead doesn’t uphold standards, no one else will. Everything flows downstream.

4. “Trust the team” is not the same as abdication.

Delegation without accountability is how you lose control of the entire project.

5. Pushback on process is a warning sign.

When someone resists specs, documentation, and conventions, they’re not just rejecting bureaucracy — they’re rejecting discipline.

The High Point: The Night It Hit Me

It was 3 AM on a weekday when I opened a critical module. A payment system — something that should have been bulletproof. Instead, I found logic so fragile it could snap if you looked at it wrong.

That was the breaking point.
Not because it was the worst code I’d ever seen — but because I realized every late night, every headache, every bug I was fixing… was something I had paid to bring into my life.

I had trusted. I had let go. I had ignored my gut.
And now, I was paying in hours, energy, and reputation.

The Embarrassment That Sticks

It wasn’t just a headache. It was an embarrassment.
The kind of embarrassment you feel in your bones when another engineer — a truly senior one you hired to replace them — looks at the code and has that face.

And here’s the kicker: a month and a half later, I’m still here, scratching my ass, cleaning it up with him.

That’s the hidden cost no one talks about. Bad hires aren’t just a mistake you make once — they’re a shadow that follows you for months.

The Wisdom (Paid in Blood, Sweat, and Lost Sundays)

If you’re building a team:

• Guard the gate. Every hire changes your company’s DNA.
• Never hire out of nostalgia. Past familiarity is not a predictor of future performance.
• Lead from the top. You can’t delegate culture and standards — you have to enforce them.
• Trust, but verify. Accountability is not micromanagement.
• Your gut is your early-warning system. Ignore it at your peril.

The Bang: Your Company Lives or Dies by Who You Let In

Hiring is leverage.
Do it right, and your company flies.
Do it wrong, and you will spend your life cleaning up problems you paid other people to create.

So hire slow. Hold the line. Ask the hard questions.
Because once someone’s inside, the damage they can do isn’t just technical — it’s personal.

And trust me: you do not want to be sitting here, at 11:58 PM on a Sunday night, staring at a bug-riddled nightmare months after they’re gone, still wondering why you didn’t listen to yourself the first time.

~ FIN ~