Most founders can tell you what a great developer hire is worth. Far fewer can tell you what a bad one costs, and that gap is exactly why mis-hires linger. The salary line looks fine on the spreadsheet. The real bill shows up somewhere else: in missed releases, in reviews that take twice as long, and in the quiet frustration of the people who have to clean up after someone who is not working out.
I have hired, and occasionally mis-hired, a lot of engineers. As a partner, I helped grow a software consulting company from about $6M to $60M in under three years, and later I founded and scaled a fully remote consultancy. Hiring at that pace teaches you one lesson over and over: the cost of a bad developer hire is mostly hidden, and it compounds every week you wait. The good news is that the warning signs usually show up early, often inside the first two weeks, if you know where to look.
The Direct Costs Everyone Counts
These are the numbers that land in a finance review, and they are real.
Recruiting spend. Job board fees, agency percentages, and the hours your team spent screening, interviewing and debating candidates. For a senior engineer, the interview loop alone can eat dozens of hours of other engineers' time.
Salary and benefits for unproductive months. Most teams do not act on a weak hire for three to six months. That is a full quarter or two of compensation for work that often has to be redone.
Onboarding and equipment. Laptops, licenses, accounts, and the setup time of whoever owns onboarding.
Replacement. When you finally part ways, you pay the recruiting cost again, plus severance in many cases, plus another ramp-up period for the next person.
Add those up and you are already looking at a meaningful fraction of a year's salary. But in my experience, the direct costs are the smaller half of the bill.
The Hidden Costs Nobody Puts on the Spreadsheet
Senior engineer time. A struggling developer pulls on your best people. Pull requests need extra rounds of review. Bugs need to be traced back and fixed. Pairing sessions stretch on. Every hour your strongest engineer spends compensating is an hour not spent on the hardest problems you hired them for.
Code that has to be unwound. Weak code does not stay contained. It gets built on top of. By the time you notice, features depend on brittle abstractions, missing tests and shortcuts that nobody else fully understands. Rewriting that later is far more expensive than reviewing it carefully now.
Delivery and customer trust. Slipped sprints turn into slipped launches. If you run client work, a slipped launch becomes an awkward conversation, and enough of those become a lost account.
Team morale. Strong engineers notice quickly when someone is not pulling their weight and leadership is not addressing it. The message they hear is that standards are optional. That is how one bad hire turns into one good engineer quietly updating their resume.
Leadership attention. Managers spend hours in extra one-on-ones, performance plans and hallway conversations. That attention is your scarcest resource as a company grows.
When you add the hidden layer, a single mis-hire can easily cost a multiple of the salary you agreed to. That is the real cost of a bad hire for a developer role, and it is why speed of detection matters more than almost anything else.
What to Watch in the First Two Weeks
Two weeks is not enough to judge someone's ceiling. It is plenty to see their habits. These are the signals I pay attention to.
How they ask questions. Good engineers ask specific, well-researched questions early: "I read the README and the deploy script, but I am not sure which environment variables are required for local setup." Worrying signs are the opposite extremes: silence for days followed by "I am blocked," or a stream of questions that a few minutes of reading would answer.
Time to first meaningful commit. Every codebase is different, but by the end of week one most capable developers can ship something small: a bug fix, a test, a documentation correction. If nothing has landed by the end of week two and there is no clear reason, take note.
Quality of the first pull requests. Small first PRs tell you a lot. Is the description clear? Did they add or update tests? Did they follow the existing patterns, or invent their own? How do they respond to review comments: with curiosity, or with defensiveness?
Honesty about progress. In standups and check-ins, do their updates match what you see in the repository? A developer who says "almost done" three days in a row on a small ticket is giving you information, just not the information they intend.
How they handle being stuck. Everyone gets stuck in a new codebase. The question is how long they stay stuck before asking for help, and whether they show what they already tried.
Fit with how the team works. Do they show up to the rituals the team relies on, write things down, and respect review norms? Raw skill matters, but a brilliant engineer who will not work inside the team's process still slows everyone down.
None of these signals alone means you made a bad hire. A pattern of three or four of them, sustained across two weeks, usually does.
How to Act Fast Without Being Unfair
Catching the signals is only useful if you respond to them. Here is the approach I have found works.
Set clear expectations on day one. Write down what a good first two weeks looks like: environment set up, a first small change merged, one feature ticket in review. If you never defined success, you cannot fairly say someone missed it.
Give direct feedback early. At the end of week one, share what you are seeing, good and bad, with specific examples. Many slow starts are fixed by a single honest conversation.
Pair them deliberately. Put the new hire with a strong, patient engineer for a few sessions. You will learn more about how they think in two hours of pairing than in two weeks of standup updates.
Decide on a short timeline. If the concerns persist after feedback and support, do not let it drift for a quarter. A clear, respectful decision at week four or six is kinder to everyone, including the person, than a slow fade at month six.
Fix the process, not just the person. Every mis-hire is also data about your hiring loop. Did your interview test the real work? Did you skip a reference check? Did you hire for speed because a deadline was looming? Close that gap so the next hire is better.
The Bottom Line
A bad developer hire rarely announces itself with a disaster. It shows up as small frictions: a vague standup update, a pull request that needs four rounds, a senior engineer who looks tired. Those frictions are expensive, and they compound. The teams that keep the cost of a bad hire low are not the ones that never make mistakes. They are the ones that define success early, watch the first two weeks closely, and act with clarity and respect when the signals line up.
If you are building or scaling an engineering team and want a second set of eyes on how you hire and onboard developers, visit https://tdzpro.com.
Ashkan Rajaee is the founder of TDZ Pro. He has spent years building and scaling software engineering teams, including a fully remote software consultancy.
Top comments (0)