The "cost to hire developers" conversation often gets reduced to salary, leading founders to underestimate the actual cost by 50-100%. Salary is the smallest line item in the engineering budget. The big costs are the ones nobody talks about: recruiting fees, search costs, productivity gaps during ramp, scalable tooling, and turnover from wrong hires. If you're budgeting "three engineers at $200k each = $600k," your real number is closer to a million, likely more.

Here's the full picture — lack of clarity at planning time becomes panic at burn time.

Salary, the headline number.

In the US in 2026, a senior software engineer at a competitive tech company makes $200-280k base, with $80-200k in equity vesting over four years, and a 10-25% bonus. A staff engineer earns significantly more. A junior makes $130-180k.

For startups competing with big-tech salaries, you're paying similar rates or not hiring senior people. Some early-stage companies trade lower salary for higher equity, but post-2022, candidates have become more selective — many now value cash after watching equity grants dilute or evaporate.

For offshore or distributed teams, the math changes. In LATAM, pay $80-160k for senior talent. In Eastern Europe, $60-130k. In South Asia, $40-100k. Salaries scale with local markets and English fluency. Top talent in any region is nearing US salaries, especially as remote-first US companies bid for them.

Salary is roughly half of what you'll pay per engineer. The rest is everything else.

Recruiting cost.

External recruiter fees: 20-30% of first-year base salary if using an agency. For a senior US hire, that's $40-80k per placement. Agencies do work — not just collecting fees — but they're expensive and sometimes pay for intros you could have made yourself.

Internal recruiter cost: $150-200k per year, handling 8-12 hires annually if focused, so $15-25k per hire. Better economics than agencies with enough volume. Worse if hiring sporadically.

Founder-led recruiting: early-stage founders should recruit themselves. The "cost" is the opportunity cost of the founder's time, the most expensive in the company, but conversion rates and candidate quality are higher. Plan for 20-40% of a founder's time on hiring during heavy quarters.

Sourcing tools (LinkedIn Recruiter, Gem, Ashby, Greenhouse): $1-3k per month. Not nothing. Often forgotten.

Interviewing time: the silent expense. For each senior hire, expect 15-30 first-round screens to find one good candidate, plus three to four hours of senior engineer time per loop candidate. Multiply by the number of candidates and interviewers. Engineering hiring at scale consumes significant senior engineer time, not spent building product.

The real all-in recruiting cost per hire, including all of this, lands somewhere in the $30-80k range for US senior hires. Plan for it.

Ramp time.

The most underestimated cost. A senior engineer joining a new company at month one is not fully productive. They don't know the codebase, team, or system. They are learning, and you're paying them to learn.

The ramp curve:

Month 1: 10-30% productive. Reading code, attending meetings, making small PRs.

Month 2-3: 40-60% productive. Shipped features, understand architecture, know who to ask.

Month 4-6: 70-90% productive. Internalized codebase, shipping at pace, mentoring others.

Month 7+: 100%+. Adapted to team velocity, contributing fully, finding leverage opportunities.

The math: a senior engineer at $250k base costs $1.5M in the first six months in raw output terms (six months at $250k annualized = $125k salary plus benefits, equity vesting, tooling, call it $180k cash, plus the productivity gap of 40-60% of full output during ramp). Hiring three at once means investing several hundred thousand dollars in ramp before full velocity.

"We're hiring three engineers and we'll be 3x faster in three months" is wrong. You'll be 0.5-1.5x faster in three months and 2-2.5x faster in six. Assuming immediate productivity is structurally optimistic.

Tooling and overhead.

Per-engineer tooling adds up faster than expected. Rough US numbers for a senior engineer in 2026:

Laptop, monitors, peripherals: $4-6k upfront, refresh every 2-3 years.

Software seats: GitHub Enterprise ($21/mo), JetBrains or VS Code (free to $20/mo), Cursor or Copilot ($20-40/mo per seat), Linear or Jira ($8-15/mo), Slack ($12-15/mo), Notion ($10/mo), 1Password ($8/mo), Datadog or equivalent observability ($30-100+/mo depending on tier and volume), AWS/cloud infrastructure (highly variable, often $50-500/mo per engineer for development environments). That's $200-700/month/engineer just in SaaS.

Cloud cost split across engineers: development environments, staging, CI runtime. Maybe $200-800/month/engineer at typical SaaS scale.

Benefits: in the US, plan 25-35% of base salary for health insurance, dental, vision, 401(k) match, etc. For a $250k base, that's another $60-90k per year.

Office (if you have one): $500-1500/month/engineer depending on city. Less if hybrid, zero if fully remote.

Equipment and tooling all-in: $15-30k per engineer per year on top of salary.

Turnover and mis-hires.

A mis-hire — someone wrong for the role who gets fired or quits within a year — costs you:

The recruiting and ramp costs above, all sunk.

The cost of replacing them, another full recruiting and ramp cycle.

The opportunity cost of what wasn't built during their tenure and the time to realize it wasn't working.

The morale cost on the team, real but unquantifiable.

Industry estimates put the all-in cost of a mis-hire at 1.5-3x the engineer's annual cost. For a senior engineer, that's $400k-$900k in pure waste per mis-hire.

Hiring slowly and well is cheaper than hiring fast and remediating. Founders under pressure to "scale the team" often make this trade poorly. The right answer: take an extra month to find the right person, run better interview loops, do reference checks properly. The savings are enormous.

Healthy churn vs. unhealthy churn.

Some turnover is healthy. Engineers leaving for life events, opportunities your company can't offer, or to start their own thing — these are normal. Plan for 10-15% annual voluntary turnover even at a great company.

Unhealthy turnover is driven by management, compensation, culture issues, or burnout. If turnover is above 20%, you have a leak costing you the hiring budget twice — paying to bring people in and again to replace them. The fix is rarely "pay more"; it's usually management.

The other category is managed exits — performance-managed out engineers. Sometimes correct (the wrong hire didn't work out), sometimes a sign of bad hiring (you hired people you knew weren't ready). The cost of a managed exit is high, both in dollars (severance, lost ramp investment) and morale.

A budget model that's more realistic.

For a US senior engineer in 2026, the fully-loaded cost in year one is roughly:

Salary: $250k

Equity: $30-50k/year vesting expense

Benefits: $75k

Tooling: $15k

Recruiting cost amortized: $40-60k

Ramp-time productivity gap: opportunity cost of $50-100k

Total year-one cost per senior engineer: $460-550k.

For a team of three: $1.4-1.65M, not $750k.

For an offshore senior engineer at $120k base, the math changes — ramp time is similar, but salary, benefits, and tooling are lower. All-in year-one cost is $180-220k. This is why distributed teams are underrated: not just salary savings (eroded as the global market converges), but savings on everything else.

For a junior engineer, salary is lower, but ramp is longer (12-18 months to full productivity instead of 6) and supervision cost is significant (a senior engineer spends real time mentoring). Juniors are good long-term investments but don't reduce short-term hiring costs.

Practical implications.

The first hire is the most expensive per output. Single hires don't benefit from a pre-existing team to ramp into. Plan accordingly.

Hiring in waves is more efficient than continuous hiring. A wave hire (three engineers starting within a month) shares ramp investment — onboarding together, helping each other, ramping faster. Don't string out hires unnecessarily.

The interview loop is engineering investment. Hours senior engineers spend interviewing are hours not building product. Optimize the loop for maximum signal in minimum time. Don't run six-stage loops if four suffice. Don't have eight people interview each candidate if four suffice.

Retention is cheaper than recruiting. The compounding cost of churn is huge. Investments in management, compensation parity, and team health are high-leverage hiring investments. Treating existing engineers well is your most cost-effective recruiting program.

Build the bench before you need it. Some of the best hires happen during quiet quarters when nobody else is hiring and great candidates are available. If you only hire when there's an immediate need, you're paying the premium of a competitive market.

The TL;DR: budget 2x what salary implies for honest engineering cost modeling. Salary is the floor, not the ceiling. The rest of the iceberg is recruiting, ramp, tooling, and the cost of getting it wrong. Plan for it or be surprised. The surprise is more expensive.