That number is maybe a third of what the hire actually costs you over the next six months. The rest is buried in your team's calendar. In code reviews that take longer. In features that ship later than planned. Most leaders never add it up. When they do, the picture shifts hard.
Start with the headline number, then keep adding
A senior developer in the US doesn't cost what their salary says. The actual first-year cost of an in-house software engineer can reach $248,000. That figure stacks recruitment and salary. Plus bonuses and taxes. Plus benefits and equipment. Plus software licenses, onboarding, and training.
Roughly double the base pay. And most of the gap lives in line items nobody mentions in planning meetings.
Even the recruitment piece alone is bigger than people think. It includes recruitment fees and internal vetting time. It also includes interviewing and onboarding. Then training. Then, the productivity is lost while the role sits open. All of it stacks up before the developer writes any code.
That's the smooth-hire scenario. The one where everything works.
Ramp-up takes longer than your sprint plan assumes
Now look at how long ramp-up actually takes. The average is somewhere between 8 and 26 weeks before a new hire is fully productive.
The range is huge because role complexity drives it. A senior dev joining a mature codebase? High-end. Not the low end. Don't kid yourself about that.
Drilling in by seniority. Senior engineers hit 90% velocity in 6 to 10 weeks. Mid-levels need 8 to 14 weeks. Juniors take 4 to 6 months. That's per Developer Onboarding Cost research.
The salary clock starts on day one. The output clock doesn't.
You're paying full freight while getting partial work. That gap is real money. Take a developer on $15,000 a month. For the first three to six months, they're running at maybe half speed. You're burning $7,500 a month on output you didn't get.
And that's just the new hire's productivity. We haven't talked about everyone else's yet.
The senior engineer tax (and why nobody budgets for it)
A new developer doesn't ramp up alone. Someone teaches them the codebase. Walks them through the deployment pipeline. Explains why that one service is named after a Norse god nobody can spell. Usually, that person is your best senior engineer. Because they're the one who actually knows.
That time costs you. A senior dev spending 5 hours a week mentoring a new hire over three months puts in 60 hours total. At $85 an hour fully loaded, that's $5,100 in opportunity cost per new joiner.
Now multiply. Hire three engineers in the same quarter, and your top senior is spending 15 hours a week not building things. Your highest-leverage person becomes the lowest-leverage person, on purpose.
This is the tax that hides best. It doesn't show up on an invoice. It shows up as a senior engineer's velocity dropping for a quarter. And nobody connects it back to last month's hiring spree.
It also compounds. Onboarding five people at once slows the whole team down. Each new hire needs support. Stack five of them, and that support eats real hours.
It compounds in ways you don't see in a Jira board.
The boring costs that add up faster than you'd think
The admin side of onboarding isn't free either. SHRM did the math on what onboarding actually costs. They landed at about $4,100 per new hire on average. Paperwork. Accounts. Orientation sessions. Security training. None of that produces any code.
Workspace setup runs another $500 to $1,000 per person. Hardware-heavy roles run higher. On top of that? New employees work at about 25% of their productivity in their first four weeks.
Each of these numbers looks small on its own. Stack them across ten hires, and you're looking at a real budget line nobody flagged in Q4 planning.
And then sometimes the hire just doesn't work
Now the really painful number.
SHRM puts the cost of replacing an employee at 50 to 60% of annual salary. Once you factor in lost productivity? The total cost of a bad hire reaches 200% of the salary. Harvard Business Review data goes further. Turnover costs run from 100% to 300% of the replaced employee's salary. And about 23% of new hires leave before their first year is up.
Roughly one in four hires resets the entire cost clock. So, everything we just calculated? The ramp-up time, the senior engineer tax, and the workspace setup? You might be paying it twice for the same role.
Why good companies still hire badly
The strange part is that smart leaders running solid hiring processes still get this wrong. The interview process for developers is broken in most companies. And not in ways the leaders running it can see from the inside.
UK research found that 74% of businesses don't use any candidate testing. 32% use non-technical professionals to interview tech talent. The result: 24% of hired candidates don't have the right technical skills for their role.
One in four. That matches the bad-hire rate from the SHRM data almost exactly. The numbers agree because the cause is the same.
But skill mismatch is only a loud failure. The quieter one is a cultural fit. Stanford research shows culturally misaligned employees are 32% less productive. Replacing a tech professional costs 50 to 200% of their annual salary.
A developer can pass every coding challenge and still be wrong for their team. They write in a style that your team has to rewrite. They skip pairing because they prefer working alone. They escalate things that should be resolved in a chat thread. None of it shows up in the interview.
The damage spreads sideways. Misaligned hires leave faster. They frustrate the engineers stuck working with them. And they slowly push your retention numbers in the wrong direction.
"Hire faster" isn't the answer most leaders think it is
When the team feels slow, the instinct is to add people. Hire faster. Push harder. Fill the gap.
The math doesn't support it. 38% of organizations say recruitment issues have delayed new IT projects. Hiring fast usually means hiring poorly, which means hiring again in six months, dragging the same team into absorbing the new joiner.
Tech employee turnover averages 13.2%. It climbs to 21.7% for embedded software engineers. And it takes one to two months to bring a developer up to speed.
If a fifth of your team turns over every year? A fifth of your senior engineers' time goes to onboarding the replacements. Forever. You never escape the ramp-up cycle because you keep restarting it.
The signals that actually matter
Most teams track the wrong metrics. Time-to-hire. Cost-per-hire. Headcount filled. All lagging indicators. All telling you about decisions you already made.
The signals worth watching show up in the first 90 days after a hire starts. First-quarter attrition for developers runs at roughly one in five. Each early exit restarts the cost clock from zero.
Three things worth measuring.
How long until a new engineer ships something real? If that number grew compared to last year, your onboarding system is breaking down before you'll notice it in any other metric.
The ratio of senior engineer hours spent mentoring versus building. When that ratio tips, you've quietly become a training organization that occasionally ships features.
The rework rate on new hires' code. If their work is redone frequently, the context transfer is failing. Not the engineer.
What a real 90-day plan actually changes
The teams that onboard well treat the first 90 days as a real plan, not a welcome email and a Jira login. Clear milestones. Defined ownership. A path from "joined" to "shipping" that doesn't rely on the new hire figuring it out.
It's a boring finding.
It's also the one that saves the most money. A structured plan shortens ramp-up. It reduces the senior-engineer mentor tax by giving the new hire a clear path. And it surfaces bad fits in weeks instead of months. Companies skip it because it feels like overhead.
The overhead is the cheap part. The replacement cycle is the expensive part. Run the numbers yourself. Prevention costs ten times less than the cure.
How Proxify changes the math
Almost every cost above traces back to two root causes. Bad selection. Slow ramp-up. Proxify is built to attack both before the developer ever touches your team's calendar.
Vetting that kills the 24% problem
The biggest cost driver in this entire stack is the bad hire. The 24% mismatch rate from the UK research drives the $150,000 to $300,000 replacement figures.
Proxify cuts that risk at the source. Our network represents the top 1% of global tech talent across more than 1,000 tech competencies. Developers average eight years of experience.
The six-step vetting process runs deep. And the people doing the vetting aren't generic recruiters. They're seasoned developers who've actually built the kind of work the candidate will do.
You stop paying for the 24% who looked good on a resume but don't have the skills.
Matching that compresses the timeline
Traditional hiring takes 35 to 82 days from intake to start date. Every one of those days is a day your roadmap is sitting still.
Proxify delivers tailored candidates in an average of 2 days. The full process, from the intro call to onboarding, takes 2 to 12 days. Their Client Engineering team is developers themselves. They work alongside proprietary AI to match technical requirements to verified skills. Not just keyword overlap on a CV.
That collapses a whole row of your cost stack. You skip the 40 hours of HR sourcing time. The LinkedIn ad budget. The external recruiter fee is 20-25% of the first-year salary.
Cultural fit, treated as the actual variable it is
The Stanford 32% productivity hit comes from misalignment. A developer who doesn't fit your team writes code your team has to rewrite. The cost shows up everywhere.
Proxify positions its developers as core team members rather than transactional freelancers. They integrate into your daily rituals. Your planning cycles. Your long-term goals. The match isn't built around what stack you use. It's built around how your team actually works.
And if the fit's still wrong? Proxify replaces the candidate within 48 hours. Or provides continuous coaching to course-correct. That's the part that matters most. It removes the six-month bleed that defines almost every bad hire scenario.
You also get a data layer that most agencies can't offer. Proxify's Stanford-backed P10Y partnership lets you benchmark performance against a network of over 6,000 professionals. The black box gets opened.
What this does to the cost stack
Run the numbers on a single senior hire, the traditional way. $4,100 in formal onboarding. $5,100 in mentor opportunity cost. $7,500 a month in lost productivity for three to six months. Plus, there is a 25% chance the hire fails, and you pay six figures to start over.
The Proxify path doesn't make those costs disappear. It shrinks them. The developer arrives pre-vetted, with verified skills aligned with the stack. Ramp-up runs shorter because the match was built around capability, not vibes. And the replacement risk gets caught in a 48-hour safety net you wouldn't otherwise have.
Conclusion
Most engineering leaders price hiring wrong. They look at the salary and call it the cost.
The real cost is the salary plus six months of senior engineer time. Plus a one-in-four chance of doing the whole thing over again. That last variable is what wrecks budgets and roadmaps. And it's the one most leaders never put in their model.
The companies that scale engineering well aren't the ones hiring fastest. They're the ones paying attention to the full cost of every hire. And investing in the selection step that determines everything downstream.
Onboarding isn't a line item. It's a system. The leaders who treat it that way are the ones who get to ship.
