The Job That Looked Fine Until Someone Added It Up
The quote said $1,450. The part shipped on time. The customer paid. By every visible signal, Job #4471 was a normal, unremarkable job — twenty-five aluminum brackets, three operations, nothing exotic. It's the kind of job a shop runs a dozen times a month without a second thought.
Then the quarter closes, and the numbers don't reconcile. Labor hours booked to the job run higher than what QuickBooks has as "cost of goods" would suggest, but nobody can point to which operation ate the difference. Was it the setup on the mill? A slow saw blade? An inspector who caught something and reworked it? The paper traveler that came back from the floor has hours scrawled in the margins, some in pencil, one crossed out. Multiply that ambiguity across forty jobs a month and the shop's margin becomes a number everyone believes roughly, but nobody can defend line by line.
This is what job costing is supposed to prevent — not by adding paperwork, but by comparing what a job was expected to cost, operation by operation, against what it actually cost. This article walks through one representative job from quote to close, showing exactly where the numbers come from and where they diverge. Every figure below is an illustrative example built to demonstrate the method — not a published benchmark — so you can follow the arithmetic and then run it against your own operation.
What a Job Cost Sheet Actually Tracks
A job cost sheet is not the invoice, and it's not the traveler, though it draws from both. At its core it tracks four things per operation:
- Standard hours — what the operation should take, per the router or routing sheet, split into setup time and run time.
- Actual hours — what got logged on the floor, from a clock-in/clock-out event or a time entry.
- Burden rate — the fully-loaded cost per hour of running that work center: machine depreciation, power, floor space, supervision, and the operator's wage rolled together.
- Material and outside-process cost — stock, hardware, plating, heat-treat, whatever gets added outside labor.
Roll those up per operation, then sum across the job, and you get standard cost and actual cost side by side. The gap between them is where margin actually lives or dies — not in the quote, and not in the invoice, but in the operations in between. For a broader look at how this fits into a shop's overall costing discipline, see our job costing for machine shops overview.
The Sample Job: Setup
Here's the job we'll walk through.
Job #4471 — Aluminum mounting bracket, qty 25 Three operations: Saw/Cut, CNC Mill, Deburr & Inspection. Quoted price to the customer: $1,450 (this is illustrative — a stand-in for a real quote, not a rate you should copy). Estimated material cost: $350 for stock across all 25 pieces.
The router calls for standard hours at each operation — a setup component (fixed, regardless of quantity) and a run component (per piece, multiplied by quantity):
| Operation | Std Setup (hr) | Std Run (hr/pc) | Qty | Std Run Total (hr) | Std Hours Total |
|---|---|---|---|---|---|
| 10 – Saw/Cut | 0.50 | 0.05 | 25 | 1.25 | 1.75 |
| 20 – CNC Mill | 1.00 | 0.20 | 25 | 5.00 | 6.00 |
| 30 – Deburr/Inspect | 0.25 | 0.08 | 25 | 2.00 | 2.25 |
| Total | 10.00 |
Ten standard hours, three operations. That's the baseline the quote was built on. Now let's see what actually happened on the floor.
Operation 10 — Saw/Cut
The saw operator clocked in for setup, then ran the cut list. Standard called for 1.75 total hours; the clock-in/clock-out log showed 2.10 hours — 0.60 for setup (a little over the 0.50 standard, probably a fixture adjustment) and 1.50 for run (versus 1.25 standard, likely stock that needed an extra pass to clean up).
At an illustrative work-center burden rate of $45/hour for the saw:
- Standard cost: 1.75 hr × $45 = $78.75
- Actual cost: 2.10 hr × $45 = $94.50
- Variance: +$15.75, entirely on the labor/burden side — a small overrun, easy to miss on its own.
Operation 20 — CNC Mill
This is where the job actually got expensive. Standard called for 6.00 hours; the logged actual came in at 7.10 hours — setup ran 1.30 hours against a 1.00 standard, and run time came in at 5.80 hours against a 5.00 standard. That's a setup overrun of 30% and a run overrun of 16%, which by themselves might look like rounding noise. Multiplied by the mill's burden rate, they aren't.
At an illustrative burden rate of $85/hour for the CNC mill (higher than the saw, reflecting the machine's cost, tooling, and the skill level required to run it):
- Standard cost: 6.00 hr × $85 = $510.00
- Actual cost: 7.10 hr × $85 = $603.50
- Variance: +$93.50 — by far the largest single dollar variance on the job.
This is the value of operation-level costing over job-level costing: a single blended "job took longer than expected" line would never tell you it was specifically the mill, specifically the setup and run combined, that drove the overrun. A traveler with a barcode or QR code tying the clocked hours back to Operation 20 makes that traceable instead of anecdotal — which is the difference between "the mill always runs long" (a guess) and "this fixture change is costing us $93 a job" (a fact you can act on).
Operation 30 — Deburr & Inspection
Standard called for 2.25 hours; actual came in at 2.65 hours — setup matched standard at 0.25, but run time ran 2.40 hours against a 2.00 standard, likely from extra time cleaning up the burrs left by the mill overrun upstream, or from a more careful inspection pass.
At an illustrative burden rate of $38/hour for the deburr/inspection station:
- Standard cost: 2.25 hr × $38 = $85.50
- Actual cost: 2.65 hr × $38 = $100.70
- Variance: +$15.20
Notice something worth flagging here even without a number attached to it: a downstream operation's overrun can be a symptom of an upstream problem, not a new one. If deburr consistently runs long on jobs where the mill also overran, that's a signal worth tracking — a scrap or rework code logged against Operation 20 (rather than a generic "ran long" note) would surface that link directly instead of leaving it to memory.
Rolling It Up: Job-Level Margin
Now sum the three operations into a single job cost comparison.
| Standard | Actual | |
|---|---|---|
| Op 10 – Saw/Cut | $78.75 | $94.50 |
| Op 20 – CNC Mill | $510.00 | $603.50 |
| Op 30 – Deburr/Inspect | $85.50 | $100.70 |
| Labor + burden subtotal | $674.25 | $798.70 |
| Material | $350.00 | $350.00 |
| Total job cost | $1,024.25 | $1,148.70 |
Against the $1,450 quoted price:
- Standard (quoted) margin: $1,450 − $1,024.25 = $425.75, or roughly 29.4% of price.
- Actual margin: $1,450 − $1,148.70 = $301.30, or roughly 20.8% of price.
That's a margin that shrank by about a third from what the quote assumed — on a job that, from the customer's side, looked completely uneventful. Multiply that gap across every job in a month and it's easy to see how a shop can hit the end of a quarter with revenue on target and margin quietly underperforming, with no single obvious cause — because the cause was never one thing, it was three small operation-level overruns that nobody added up until now.
This is also, worth noting, a case for standard costing over pure historical averaging: the standard (10.00 hours, $674.25 labor/burden) is what the quote should have been checked against before it went out, and it's the only stable baseline against which "actual ran long" means anything specific. For more on how to build and maintain those standards in the first place, see standard costing for job shops.
Where This Breaks Down in Spreadsheets — and What Closes the Gap
None of the arithmetic above is hard. A spreadsheet can hold this table for one job without difficulty. The problem is scale and timing: the moment a shop is running forty jobs a month across a dozen work centers, someone has to manually collect the actual hours from paper travelers, key them into the sheet, look up the right burden rate, and do the subtraction — for every operation, on every job, before the variance means anything. In practice, that step gets skipped until quarter-end, at which point the specific cause of a specific overrun is three months gone from memory.
The mechanism that closes that gap isn't more spreadsheet formulas — it's capturing the actual hours at the operation itself, at the moment they happen, tied to a job and work center that already carries its burden rate. That's the core of what a routing and traveler system does structurally: a router defines the standard hours per operation once, a traveler carries that job through the floor, a clock-in/clock-out event (or a supervisor-approved manual entry) logs the actual against the specific operation, and the actual-vs-quoted comparison is already sitting there waiting instead of needing to be reconstructed. WorkTickets is built around exactly that loop — routing, traveler, clock-in, and the resulting actual-vs-quoted and job-profitability views — as a standalone layer that sits below full ERP, for shops that don't need scheduling or inventory management bolted on to get operation-level cost visibility.
If you'd rather work through your own job this way before deciding whether to automate it, the per-operation job costing breakdown covers the mechanics in more depth, and the job cost sheet template gives you a starting structure. For the full picture of how these pieces connect, the job costing resource hub is the index.
To run this exact walkthrough — standard hours, actual hours, burden, and the resulting margin — on your own jobs without rebuilding the spreadsheet from scratch, download the Job Costing & Quoted-vs-Actual Workbook. It's built with the same operation-by-operation structure used above, ready to drop in your own standards, actuals, and burden rates.
