Compensation Benchmarking: What to Pay, How to Decide, and Why Most Companies Get It Wrong
You’re hiring a software engineer.
You don’t know what to pay them.
So you guess. You offer 120k. They accept.
Three months later, you’re hiring another engineer. Same role. Same level.
You offer 140k. They’re excited.
Now you have two people doing the same work, same level, different pay.
The first engineer finds out. They’re furious. They leave.
You’ve just created a retention problem by not doing compensation benchmarking.
This is a common story. Companies don’t know what to pay. So they guess. They overpay. They underpay. They create internal inequity. They damage retention and morale.
Compensation benchmarking isn’t complicated. But most companies don’t do it. And that costs them money and people.
Here’s what to pay, how to decide, and why most companies get it wrong.
Why Most Companies Get Compensation Wrong
Most companies make compensation decisions based on:
Reason 1: Gut Feel
“I think we should pay them 110k.”
Why 110k? Because that’s what feels right. Or because that’s what their last company paid. Or because that’s what the CEO paid themselves once.
Gut feel is not data. Gut feel is bias. Gut feel leads to bad decisions.
Reason 2: What They Asked For
“They asked for 130k. Let’s offer 120k and negotiate.”
But what should they actually be paid? Nobody knows. So you negotiate based on what they want, not what the market says.
This creates inequity. The person who negotiates well gets more than someone equally qualified who doesn’t negotiate.
Reason 3: What You Paid the Last Person
“We paid the last engineer 125k. Let’s pay this one 128k.”
But was 125k right? Did market conditions change? Is this person more or less experienced?
You’re just copying the past without asking if the past was right.
Reason 4: What Your Competitors Pay (Sort Of)
“Google pays engineers 180k. We should pay 150k to be competitive.”
But you’re not Google. Google has way more money. Google’s costs are different. Google’s market is different.
You’ve compared yourself to a company that’s not comparable.
Reason 5: Arbitrary Tiers
“Junior engineers: 90-110k. Mid-level: 110-150k. Senior: 150-200k.”
But where did these numbers come from? Are they based on market data? Or did someone just make them up?
If they’re made up, they’re probably wrong.
Reason 6: Infrequent Review
You set compensation in 2021. Now it’s 2026. Market has changed. Costs have changed. People now make 30% more for the same role.
But you haven’t changed compensation because you haven’t reviewed it.
Your compensation is now significantly below market. Your people know it. They leave.
All of these lead to the same problem: Compensation that’s not based on market reality.
What Compensation Benchmarking Actually Is
Compensation benchmarking means finding out what the market actually pays for a role.
Not what you think the market pays. What it actually pays.
This requires research. Good data. Regular updates.
Compensation benchmarking answers these questions:
- What’s the market rate for this role in this location?
- What’s the range? (10th percentile to 90th percentile)
- What percentile should we target? (Are we a 50th percentile company or 75th?)
- How does our current pay compare?
- What should we pay?
How Market Rates Actually Work
Market rates are not fixed. They vary based on:
Location
A software engineer in San Francisco makes more than a software engineer in Columbus.
Not because they’re better. Because cost of living is different. Demand is different. Competition is different.
San Francisco: 180-250k Columbus: 130-180k Rural area: 100-140k
Your location matters.
Role and Level
Senior engineer makes more than junior engineer. That’s obvious.
But the distinction matters.
Is this person:
- Junior (0-2 years experience)?
- Mid-level (2-5 years)?
- Senior (5+ years)?
- Staff/Principal (senior+ with scope)?
Each level has a different market rate.
Industry
Software engineers make more in fintech than in nonprofits.
Not because fintech engineers are better. Because fintech has more money.
Fintech: 200-280k Tech: 150-220k Nonprofit: 80-120k
Your industry matters.
Company Size
Software engineers at early-stage startups make less than at big tech companies.
Early-stage startup: 120-160k Scale-up (50-500 people): 140-190k Large tech company: 180-250k
Your company size matters.
Experience and Specialization
A Python engineer with 10 years experience makes more than a Python engineer with 2 years.
A DevOps engineer specializing in Kubernetes makes more than a generalist.
Experience and specialization matter.
The Right Way to Do Compensation Benchmarking
If you want to get compensation right, here’s how.
Step 1: Define the Role Clearly
“Senior Software Engineer” is too vague.
Be specific:
- What do they actually do?
- What’s their scope of responsibility?
- What level of seniority?
- What specialization (if any)?
Example: “Senior Backend Engineer, 5+ years experience, leading backend architecture for a 500-person SaaS company, location: US remote with occasional SF travel”
Step 2: Research Market Data
Use multiple sources:
Free sources:
- Levels.fyi (ask people what they make)
- Blind (anonymous salary data)
- Glassdoor (salary reports)
- LinkedIn (salary insights)
- Payscale (self-reported data)
Paid sources:
- Radford (expensive, comprehensive)
- Mercer (expensive, comprehensive)
- Salary.com (affordable, reasonable data)
- PayScale Enterprise (subscription)
- Equifax (subscription)
Primary research:
- Ask your network (what do you pay for this role?)
- Talk to recruiters (what are candidates asking for?)
- Look at job postings (what are competitors offering?)
Don’t rely on one source. Use multiple sources. Look for patterns.
Step 3: Calculate the Range
From your research, you should see a range.
Example for a Senior Software Engineer in San Francisco:
- 10th percentile: 160k
- 25th percentile: 180k
- 50th percentile (median): 210k
- 75th percentile: 240k
- 90th percentile: 270k
The range is 160k-270k. Most people fall in the 180k-240k range.
Step 4: Define Your Positioning
Where do you want to be in that range?
Are you a startup competing for talent? Pay 75th percentile (240k).
Are you profitable and focused on efficiency? Pay 50th percentile (210k).
Are you early-stage with limited budget? Pay 50th percentile for critical roles, 25th percentile for others.
But make a deliberate choice. Not a default. Not a guess.
Step 5: Set Bands
Set salary bands for each role.
Example band for Senior Software Engineer:
- Minimum: 200k
- Midpoint: 230k
- Maximum: 260k
This band is your guide. You pay people within this band based on:
- Experience
- Specialization
- Performance
- Internal equity (not paying someone more just because they asked for it)
Step 6: Build Internal Equity
Once you have market rates, ensure internal equity.
Don’t pay someone more just because they negotiated well.
Pay based on role, level, and market rate.
Example:
- Senior Engineer 1: 225k (5 years experience)
- Senior Engineer 2: 230k (6 years experience, leading team)
- Senior Engineer 3: 235k (8 years experience, leading multiple teams)
This shows clear progression. It’s fair.
Don’t do this:
- Senior Engineer 1: 240k (negotiated well)
- Senior Engineer 2: 200k (didn’t negotiate)
- Senior Engineer 3: 210k (didn’t know market rate)
This creates resentment.
Step 7: Factor in Total Compensation
Salary isn’t the only thing people care about.
Total compensation includes:
- Salary
- Bonus (usually 15-25% for non-sales roles, 50%+ for sales)
- Equity (stock options, for startups)
- Benefits (health insurance, 401k match, PTO)
- Other (flexible work, professional development budget, etc.)
Example:
- Salary: 200k
- Bonus: 30k (15%)
- Equity: 50k/year (over 4 years)
- Benefits: 20k
- Total: 300k
When benchmarking, know whether you’re comparing salary or total comp. Usually it’s total comp.
Step 8: Review Regularly
Markets change. Inflation happens. Demand shifts.
Review compensation benchmarking at least annually.
Have you fallen behind market? Ahead of market?
Adjust if needed.
Common Mistakes to Avoid
Mistake 1: Using Only One Source
Different sources give different data. Levels.fyi might show higher salaries than Payscale. Glassdoor might show lower.
Use multiple sources. Look for patterns.
Mistake 2: Confusing Role with Person
“We pay this person 150k.”
But what’s the market rate for the role? If it’s 180k, you’re underpaying.
If it’s 120k, you’re overpaying.
Pay based on the role and market, not just what you can afford.
Mistake 3: Paying for Loyalty
“This person has been here three years. We should pay them more than new hires.”
But what’s the market rate? If the market is 150k and you’re paying your loyal employee 130k, pay them 150k. Don’t keep them underpaid because they’ve been loyal.
Pay market rate. Loyalty is a bonus, not a substitute for fair pay.
Mistake 4: Negotiation as the Basis
“They asked for 160k. Let’s offer 140k and negotiate to 150k.”
But what’s the market rate? If it’s 155k, offering 140k is a lowball offer. You’re negotiating below market.
Use market data. Make an offer based on market. Small negotiation is fine. But don’t negotiate down from below market.
Mistake 5: Paying Below Market to “Save Money”
“We can only afford to pay 120k for this role.”
But the market rate is 150k. So you’ll either hire someone underqualified or lose candidates to competitors.
And you’ll have high turnover. Because they’ll leave as soon as they realize they’re underpaid.
Paying below market costs more in the long run (turnover, lower quality). Pay market rate. If you can’t afford it, reconsider the role.
Mistake 6: Not Being Transparent
Most companies don’t tell people what the salary range is.
This creates inequity. People negotiate based on what they think the job pays, not what it actually pays.
Be transparent. “This role pays 140-160k depending on experience.”
Transparency reduces negotiation conflict. People know what’s fair. People feel respected.
Mistake 7: Tying Compensation to Performance
Performance bonuses make sense. “Hit your goals, get a bonus.”
But base salary should be based on market rate and role, not performance.
If you tie base salary to performance, you create two problems:
- High performers might leave because their base salary stays the same
- Low performers are underpaid even if they’re still adequate
Separate base (market-based) from bonus (performance-based).
Mistake 8: Not Adjusting for Experience
All senior engineers are not the same.
A senior engineer with 3 years at this company is different from a senior engineer with 15 years in the industry.
Adjust compensation for experience and specialization.
Implementation: How to Build a Compensation Strategy
Month 1: Assess Current State
Where are you now?
- What are you paying for each role?
- What’s the range within each role?
- How much variance is there? (Are some people way overpaid, others underpaid?)
- Is there internal equity? (Are similar people paid similarly?)
Be honest. This is the baseline.
Month 2: Research Market Data
For your top 10 roles:
- Use multiple data sources
- Research market rates in your location and industry
- Calculate the range for each role
- Identify patterns
Spreadsheet this. “Senior Engineer: Levels.fyi shows 200-240k, Blind shows 190-250k, Glassdoor shows 180-230k. Median: 210k.”
Month 3: Define Your Positioning
For each role, decide where you want to be.
Decide based on:
- Company financial situation
- Talent market (can you find people at 50th percentile or do you need 75th?)
- Competitive positioning (do you want to be known as a high-paying company?)
Document this. “We pay 75th percentile for engineering, 50th percentile for operations.”
Month 4: Set Salary Bands
For each role level, set a band.
Example:
- Junior Software Engineer: 110-140k
- Mid-level Software Engineer: 140-180k
- Senior Software Engineer: 180-220k
- Staff Engineer: 220-280k
Month 5: Evaluate Current Compensation
How do your current people compare to the bands?
Create a spreadsheet:
- Name
- Role
- Experience
- Current Salary
- Band Minimum
- Band Maximum
- Midpoint
- Variance (current vs midpoint)
This shows who’s overpaid, underpaid, and fairly paid.
Month 6: Create an Adjustment Plan
Some people are below band. Some are above.
Create a plan:
- People significantly below band: Adjust now (fairness, retention)
- People slightly below band: Adjust over time (budget)
- People above band: Grandfather (don’t cut pay)
- New hires: Pay within band
Communicate the plan. “We’re adjusting compensation to be fair and market-based. Here’s how it affects you.”
Month 7: Implement for New Hires
Use the bands for all new hire offers.
“This role’s band is 140-180k. Based on your experience, we’re offering 155k.”
Month 8: Ongoing Management
- Review annually (inflation, market changes)
- Adjust bands as needed
- Use bands for all compensation decisions
- Be consistent and transparent
The TPC Case Study: Moving from Guesswork to Data-Driven Compensation
We worked with a Series B startup. 60 people. Compensation was a mess.
Their situation:
- No salary bands
- People negotiated what they wanted
- Huge variance within roles
- No relationship to market
- High turnover, especially among underpaid employees
Example of their chaos:
- Designer 1: 100k (didn’t negotiate)
- Designer 2: 130k (negotiated well)
- Designer 3: 110k (accepted lowball offer)
Same role, same level. 30k difference.
Designers 1 and 3 found out. They were furious. Both left.
We helped them fix it.
Step 1: Research Market (Month 1-2)
We researched compensation for their top 10 roles.
San Francisco market data (their location):
- Junior Designer: 90-110k
- Mid-level Designer: 120-150k
- Senior Designer: 150-190k
- Product Manager (mid-level): 140-180k
- Software Engineer (mid-level): 160-220k
Step 2: Define Positioning (Month 2)
They decided: “We’ll pay 60th percentile for all roles.”
This means:
- They’re above average, but not top-tier
- They’re competitive for talent
- It’s sustainable for a Series B company
- It’s fair to employees
Step 3: Set Salary Bands (Month 3)
Bands for design team:
- Junior Designer: 95-115k
- Mid-level Designer: 125-155k
- Senior Designer: 160-190k
Step 4: Evaluate Current (Month 3-4)
Current designers against new bands:
- Designer 1 (100k): Below band (should be 125-155k)
- Designer 2 (130k): Within band
- Designer 3 (110k): Below band (should be 125-155k)
Designers 1 and 3 should get raises.
Step 5: Create Adjustment Plan (Month 4)
Adjustment plan:
- Designer 1: Raise to 130k (mid-band)
- Designer 2: No change (already within band)
- Designer 3: Raise to 135k (mid-band, slightly higher for loyalty)
Budget: 35k in raises
Step 6: Communicate (Month 4)
They communicated the new compensation philosophy:
- Market-based
- Transparent bands
- Fair and consistent
- Here’s your new salary
Designers 1 and 3 were relieved and grateful.
Designer 2 was happy to stay.
Step 7: Implement for New Hires (Month 5+)
New hires got offers within the bands.
No more negotiation-based pay. Data-based pay.
Results After 12 Months:
- Retention improved 40% (especially in design team)
- New hires felt fairly paid
- Internal equity improved
- Compensation discussions became simpler
- People trusted the company’s fairness
Tools and Resources
If you want to do compensation benchmarking, here are tools:
Free:
- Levels.fyi (crowd-sourced salary data)
- Blind (anonymous salary data)
- Glassdoor (salary reports)
- LinkedIn Salary Insights (some markets)
- Payscale (free version)
- Bureau of Labor Statistics (free government data)
Paid:
- Salary.com (affordable, reasonable coverage)
- PayScale Enterprise (subscription-based)
- Equifax Salary Data (subscription-based)
- Radford (expensive, very comprehensive)
- Mercer (expensive, very comprehensive)
DIY:
- Ask your network (what do you pay?)
- Call recruiters (what are candidates asking?)
- Look at job postings (what are competitors offering?)
Build your own:
- Create a spreadsheet of role, location, experience, salary
- Track it over time
- Use it to identify patterns
The Bottom Line
Most companies get compensation wrong because they don’t do benchmarking.
They guess. They negotiate. They copy the past. They pay based on gut feel.
This creates:
- Underpaid employees who leave
- Overpaid employees who are budget-drains
- Internal inequity that creates resentment
- Retention problems
Companies that get compensation right do benchmarking.
They research the market. They set bands. They pay based on data.
This creates:
- Fairly paid employees who stay
- Consistent compensation across similar roles
- Transparency and trust
- Better retention
Compensation benchmarking isn’t complicated. It requires some research and discipline. But the payoff is significant.
Ready to Get Compensation Right?
If your company’s compensation is based on guesswork, it’s time to change.
TPC helps you research market data. Define your positioning. Set salary bands. Implement fairly.
Because fair compensation is about more than money. It’s about respect. And respect determines whether people stay.
