What's in a Role? The Hidden Cost of Job Title Mismatches
When job titles don't match actual responsibilities, everyone loses. Here's how misaligned roles damage productivity and ROI.
The Problem Is Often Simply Accepted
You hire a Senior Developer expecting architectural decisions and mentorship. Instead of solving the big issues, they're writing CRUD endpoints. Or perhaps it's the new Junior Developer who finds themself drowning in production incidents they're not equipped to handle. Contractors aren't immune either, often being asked to make strategic technology choices that will outlive their three-month engagement.
The mismatch between job specifications and actual responsibilities is a common - and expensive - problem in software teams. Despite being widely experienced, organisations rarely address it systematically or plan to avoid it.
The Senior Developer
| What the job spec says | What they actually do |
|---|---|
| Lead technical architecture decisions | Write tickets assigned by a project manager |
| Mentor junior team members | Attend meetings where their input isn't sought |
| Drive best practices and code quality | Fix bugs in legacy code with no time for refactoring |
| Collaborate with stakeholders on technical strategy | Work in isolation with no one to mentor |
Senior developers writing code isn't the problem - that's often valuable. They should be tackling the hardest 5% of problems: proof-of-concepts for new architecture, solving complex performance issues, establishing patterns for the team to follow. The problem is when they're stuck writing straightforward CRUD endpoints while lacking influence over architecture and technical direction.
I worked with a senior developer who had no time for any of this. They spent their days handholding a junior hire who wasn't up to the job. Complete timesink. The senior's expertise went into remedial mentoring while critical architectural decisions went unmade. The junior wasn't at fault - they'd been hired into a role they weren't ready for, a systemic failure that hurt everyone.
Expensive senior hires become frustrated and disengaged when they're not using the skills you're paying for. Within six months, they're interviewing elsewhere.
A senior developer earning £70k who leaves after six months costs roughly £100k when you factor in recruitment, onboarding, and lost productivity. Actually, recruitment inflation and turnover costs are surging. Industry standards indicate a "bad hire" or mismatch leading to early turnover costs roughly 3x the annual salary (£210k) when factoring in recruitment fees, onboarding, and lost velocity.
The Junior Developer
| What the job spec says | What they actually do |
|---|---|
| Learn from experienced team members | Debug production issues alone at 11pm |
| Work on well-defined tasks with clear requirements | Implement features with vague requirements and no guidance |
| Gradually take on more responsibility | Make architectural decisions because no one else is available |
| Receive regular code reviews and feedback | Learn by trial and error (mostly error) |
Junior developers either burn out from stress or develop bad habits that become technical debt. Either way, the ROI expected from an affordable hire doesn't materialise.
A junior developer who takes twice as long to deliver features and creates technical debt requiring senior time to fix isn't saving money - they're costing more than a mid-level hire would have.
The Contractor
| What the contract says | What they actually do |
|---|---|
| Deliver specific features within a defined timeframe | Make framework choices that will affect the codebase for years |
| Work within existing architectural patterns | Design database schemas with no knowledge of future requirements |
| Document work for handover | Implement patterns that permanent staff don't understand |
| Provide specialist expertise for a fixed period | Leave before anyone realises the technical debt they've created |
The problem here isn't the contractor - it's the structural risk. When organisations lack clear architecture ownership, proper onboarding, or adequate documentation, contractors are forced to make decisions they shouldn't be making. Under delivery pressure, they optimise for speed because that's what they're measured on.
Short-term delivery comes at the cost of long-term maintainability. Permanent teams inherit code they can't modify without breaking things.
The "cheap" contractor who delivers quickly but leaves behind unmaintainable code can cost 3-5x their day rate in remediation work over the following year.
The Real Cost
These aren't just frustrations - they're line items on your balance sheet. Based on a typical 5-person UK development team:
The Senior "Drift" Cost: A senior developer (£70k) spending 33% of their time on technical debt or junior-level work represents £23,100 in direct salary waste.
The Technical Debt Tax: Stripe's Developer Coefficient report found that the average developer spends 13.5 hours per week (roughly 33% of their time) solely on technical debt.
The Interruption Tax: Research from the University of California, Irvine shows it takes an average of 23 minutes to return to deep focus after an interruption. If your senior is interrupted five times a day for non-senior tasks, you lose two hours of peak productivity daily - roughly £17,500 of high-value output per year.
Conservative estimate: £80k-£150k annual waste for a single five-person team
Before factoring in recruitment costs from turnover, technical debt remediation, missed deadlines, and team morale issues.
In part two, I'll cover practical solutions for fixing role misalignment and preventing these costly mismatches. Read part two.
If this sounds familiar and you'd like help auditing your team structure, I've spent eighteen years building and leading engineering teams, including as CTO through a successful acquisition. Get in touch.