How to Calculate a Fully-Loaded Employee Cost (the Number Your Margin Lives On)

Every margin calculation an agency runs has the same shape: revenue on one side, hours multiplied by a cost per hour on the other. The revenue side is usually right — invoices are hard to get wrong. The cost side is where the fiction starts, and it starts with one specific shortcut: salary divided by 2,080.

It feels rigorous. It is a real salary and a real number of nominal working hours (52 weeks × 40 hours). It is also not what anyone costs, and the error is not small or random — it is systematically low, by 60–80%, for every person in the building. When I first rebuilt this number properly at the agency where I was CTO, the entire margin report moved, every project at once, none of them in the pleasant direction.

Here is the calculation done properly. Six steps, one worked example, and a note at the end on what deliberately doesn't belong in it.

Step 1: start with the full base salary

Take the person's gross annual salary — before income tax, exactly as it appears in the employment contract. For our worked example: a mid-level developer on £55,000.

Resist the temptation to use a role average at this stage. The whole point of a fully-loaded cost is that it belongs to a named person. Role averages are for estimating future work; costing delivered work at role averages is how a project staffed with your most expensive senior reports the same cost as one staffed with a mid — which is precisely the information you needed the report to show. (Why sold rates and cost rates must be kept apart is its own argument.)

Step 2: add employer payroll tax

In the UK this is employer's National Insurance — the tax the agency pays on top of the salary, invisible on the employee's payslip. At current rates it runs to roughly £6,300 on a £55,000 salary. In other jurisdictions substitute the local equivalent (employer social contributions in most of the EU run considerably higher than the UK figure).

This is the most commonly forgotten line, because it appears on no payslip and in no contract — only in the payroll run. Running total: £61,300.

Step 3: add pension and contracted benefits

Employer pension contribution at the UK auto-enrolment minimum adds roughly £1,600 on this salary; agencies that contribute above the minimum should use their real figure. Add any contracted benefits with an invoice attached: private medical, life cover, wellbeing allowances. For our example, minimum pension only. Running total: £62,900.

Step 4: add direct per-head costs

The costs that exist because this person exists, and would stop if they left:

• Laptop and peripherals, amortised over their replacement cycle — call it £800 a year
• Software licences and seats tied to the person (IDE, design tools, the per-seat tail of your stack) — commonly £1,000–1,500 a year for a developer
• Recruitment fee amortised over expected tenure, if you want to be strict — we round it into the figure above

Call it £2,100 for our example. Running total: £65,000 — a tidy coincidence, and a memorable rule of thumb: a £55k developer is a £65k cost before they log a single hour.

Step 5: divide by hours actually available — not 2,080

The salary buys 365 days. Work happens on far fewer:

• 260 weekdays in a year
• minus ~25 days holiday
• minus 8 bank holidays
• minus a realistic ~5 days sickness

That is roughly 222 working days, or about 1,650 hours at seven and a half productive hours a day. Dividing: £65,000 ÷ 1,650 ≈ £39 an hour — already half as much again as the naïve £26.

One refinement separates the good calculations from the great ones. Those 1,650 hours include company all-hands, internal meetings, training and reviews — hours you pay for that no project can ever absorb. Most agencies fold that time back into the rate by dividing by deliverable hours instead (typically 1,400–1,500 for a delivery role), which lands our developer at £43–46 an hour. Add richer benefits or a London cost base and you reach the top of the honest range: £43–52 for a £55,000 developer.

Step 6: sanity-check it against the margin report

The final step is to feel the consequence. Take one recent project and re-run its labour cost with the fully-loaded figures instead of the naïve ones. On a project with 1,000 logged hours, the difference between costing at £26 and costing at £45 is £19,000 of cost that the old report simply did not contain — on one project.

This is usually the moment the room goes quiet. Margins that looked like a comfortable 50-something percent shed fifteen or twenty points in a single recalculation, before overhead allocation and unbilled scope have even entered the conversation. The full journey from labour margin to real margin is mapped in what project margin actually is — the fully-loaded cost is component one of three.

What deliberately doesn't belong in this number

A common over-correction is to load everything into the hourly cost — rent, operations salaries, marketing, the office plants. Resist it. General overhead belongs in a separate, project-level allocation (pro-rata to each project's share of revenue), not inside individual cost rates. Two reasons: baked into rates, overhead becomes invisible and unmanageable as its own line; and it distorts comparisons — a person is not more expensive because the agency signed a longer lease.

The clean rule: the fully-loaded cost contains what the agency pays because this person exists. The overhead allocation contains what the agency pays because the agency exists. Keep the two apart and both stay honest.

Maintaining it without a spreadsheet ritual

The calculation above is twenty minutes per person in a spreadsheet — and then it drifts: salaries rise, people join and leave, and eighteen months later the margin report is quietly running on last year's costs.

This is the number Saldo keeps alive. Each person's fully-loaded cost is held once, in a private ledger only leadership can see, and every Jira worklog is costed against it continuously — so the margin figure on every project reflects what your people cost now, not at the last spreadsheet ceremony. The 15-minute demo shows the whole chain on your own Jira data, and our pricing is flat per month, not per head — so the count of people you cost has no bearing on the bill.

The shorter version: salary ÷ 2,080 is not a cost, it is an underestimate wearing one's clothes. The real number is everything the person costs, divided by the hours you can actually deploy — and until it is right, no margin number downstream of it can be.