When the Job Closes and Nobody Can Say Whether It Made Money
The job shipped on time. The customer paid. And when the owner pulls the folder at quarter-end to see how it actually did, there's a traveler with handwritten times, a purchase order for material, and a QuickBooks entry that lumps the labor into "shop wages" for the month. Nothing on that job ties the hours anyone actually worked back to the hours that were quoted. Multiply that by forty jobs a month and the shop's income statement is accurate at the company level and useless at the job level — which is exactly the level where margin is won or lost.
This is the normal state for a shop running QuickBooks, a spreadsheet, and paper travelers. It isn't a discipline problem. It's a structural one: none of those tools carry a job's standard — the time and cost it was quoted at — forward to compare against what actually happened, operation by operation, while the job is still open.
Job costing for machine shops is the method that closes that gap. Done completely, it has five moving parts, a specific order of operations, and one output that matters more than the rest: an actual-vs-quoted number you can see before the job ships, not after the quarter closes.
The Five Inputs a Real Job Cost Needs
A complete job cost, for a single part number running through a shop, is built from five inputs:
- The routing standard — the sequence of operations the part requires, and the standard (quoted) time for each one.
- Actual labor — the time actually logged against each operation, by whoever ran it.
- Burden or machine rate — the fully-loaded cost per hour of running that work center, not just the wage.
- Material cost — what the raw stock, purchased components, or outside processing actually cost for this job.
- Scrap and rework cost — the labor and material burned re-doing work, tied back to the operation that caused it.
Most shops have pieces of this. A router lives in someone's head or an old traveler template. Labor gets logged, sort of, on paper. Burden gets estimated once a year for quoting and never revisited. Material cost sits in the PO system. Scrap gets noticed on the floor and forgotten by the time anyone's building the next quote. None of it is wrong, exactly — it's just never assembled into one job cost sheet while the job is still open enough to do anything about it.
The rest of this method walks through assembling those five inputs in order, and a full worked job costing example shows the arithmetic end to end.
Step 1: Build the Routing Standard, Operation by Operation
Job costing starts before the job does — at quoting, when the shop commits to a routing: the ordered list of operations (saw, mill, deburr, inspect, and so on) and a standard time for each. This is the quoted side of the eventual actual-vs-quoted comparison, and it has to exist at the operation level, not just as a single lump "estimated hours" figure for the whole job.
The reason is simple: if the standard only exists at the job level, a variance at the end of the job tells you the job ran over — but not where. A job that's 20% over on setup at the mill but on-target everywhere else needs a different fix than a job that's over on every operation. Per-operation job costing is what makes that diagnosis possible, and it only works if the routing standard was broken into operations from the start.
For shops that have never formalized this, standard costing for job shops is worth treating as its own project before layering job costing on top — the routing standard is the foundation everything else in this method rests on.
Step 2: Capture Actual Labor at the Same Level as the Standard
The standard is only half the comparison. The other half is what actually happened, and it has to be captured at the same granularity — by operation, not by shift or by job total.
In practice, this means whoever runs an operation logs in and out of it: a clock-in at the start of setup, a transition when setup ends and run begins, a stop for waiting (material late, machine down, waiting on a fixture) if it happens, and a clock-out at the end. Those reason codes — setup, run, waiting, rework — matter because a job that ran long on "waiting" has a scheduling problem, not a labor-rate problem, and the fix is different.
Paper time tracking makes this granularity expensive to maintain by hand, and the cost of getting it wrong is measurable: calculation error rates with paper time tracking can run as high as 8% of total payroll, according to Timeero. Separately, the American Payroll Association's often-cited estimate, via Homebase, puts time theft — buddy punching, rounding in one direction, forgotten clock-outs — at up to 5% of gross payroll annually. Those are payroll-accuracy numbers, not job-costing numbers on their own, but they point at the same root cause this method is built to fix: labor data that isn't captured at the operation, in the moment, by the person doing the work.
Actual-vs-quoted labor tracking is the practice of pulling those two data sets — the operation-level standard from Step 1 and the operation-level actual from Step 2 — into the same view, for the same job, while it's still open.
Step 3: Roll Work-Center Burden Into the Job
Labor hours alone aren't a job cost — they're an input to one. The other input is the fully-loaded cost of the work center itself: not just the machinist's wage, but the machine's depreciation, power, tooling wear, floor space, and supervision allocated to that hour of run time. This is the burden rate, and it has to be set per work center, because a manual deburr bench and a five-axis mill do not cost the same amount to run for an hour.
Worked example (illustrative, not a published benchmark): say a shop rolls up a work center's annual costs — machine depreciation, power, maintenance, allocated floor space and supervision — to $180,000, and the work center runs 2,000 productive hours a year. That's a burden rate of $90/hour for that center. If a machinist earning a wage that rolls up to $30/hour actual labor cost runs a job on that center for 4 hours, the labor-plus-burden cost for that operation is 4 × ($30 + $90) = $480 — not the $120 you'd get from labor alone. That gap is the entire reason burden-rate work matters: quoting off labor rate alone systematically underprices work-center-heavy operations.
For shops that haven't set rates by work center before, how to calculate a machine shop's hourly rate walks through the full roll-up, and standard costing for job shops covers how those rates feed back into the quoting standard from Step 1.
Step 4: Run the Actual-vs-Quoted Comparison
With a routing standard (Step 1), operation-level actuals (Step 2), and a real burden rate (Step 3), the comparison finally has all its parts: for each operation, actual time × loaded rate versus quoted time × loaded rate. Roll that up across every operation in the job and the job-level actual-vs-quoted number appears — while the job may still be open enough to do something about it, not three weeks after invoicing.
A quote is a bet on how long an operation will take. Job costing is the record of whether the bet paid off — and the only way to know which operations are chronically underquoted is to compare the two at the same level, every time, not just when a job feels like it ran long.
This is also where the diagnosis gets specific. A job running 15% over on total hours could be one operation running 60% over and the rest on target, or it could be everything running 15% high — and those point at completely different root causes: a bad standard on one operation versus a systemic rate problem across the shop. Actual-vs-quoted labor tracking only earns its keep at the operation level; a single job-total comparison hides exactly the pattern a shop needs to see.
Step 5: Log Scrap and Rework Against the Causing Operation
The fifth input — scrap and rework — is the one most shops track least formally, and it's expensive to skip. EASE.io puts scrap and rework costs at up to 2.2% of annual revenue for the average manufacturer. Cost-of-poor-quality estimates run considerably higher across a broader definition: Jama Software puts total cost of poor quality at typically 15–20% of sales, with a documented range of 5–35% depending on the operation, and Autodesk cites a similar 15–20% figure for mature operations. Those are different measures of overlapping territory — scrap/rework is a component of the broader cost-of-poor-quality figure — but both point at the same conclusion: quality cost is not a rounding error, and most of it never makes it onto a job cost sheet at all.
The fix is mechanical, not cultural: when a part gets scrapped or reworked, the labor and material burned on that event get logged against the specific operation that caused it — not absorbed into general overhead, and not written off as "normal." Over a handful of jobs, this turns a vague sense that "the deburr step causes problems" into a specific, defensible number tied to a specific work center and a specific root cause. That number belongs on the job cost sheet next to labor and burden, and it belongs in the next quote for a similar part.
A Worked Job Cost Example
Putting all five inputs together for one job, illustratively:
- Material: $850 (stock plus one purchased fastener kit)
- Operation 1 — Saw: quoted 0.5 hr, actual 0.5 hr, work-center rate $45/hr → $22.50
- Operation 2 — Mill (setup + run): quoted 3.0 hr, actual 4.1 hr, work-center rate $90/hr → $369 actual vs. $270 quoted
- Operation 3 — Deburr/Inspect: quoted 0.75 hr, actual 0.9 hr, work-center rate $45/hr → $40.50 actual vs. $33.75 quoted
- Rework (one part rejected at inspection, re-run at Mill): 0.6 hr at $90/hr → $54, logged against Operation 2
- Total actual cost: $850 + $22.50 + $369 + $40.50 + $54 = $1,336
- Total quoted cost basis (excluding rework, which wasn't quoted): $850 + $22.50 + $270 + $33.75 = $1,176.25
The job shipped and the customer was billed the quoted price. But the job cost sheet shows the milling operation ran 37% over standard time before rework even entered the picture, and that one operation — not the job as a whole — is where the next quote for this part needs to change. That's the entire point of building the cost at the operation level instead of the job level: the fix is precise instead of a shop-wide guess.
A structured version of this exact worked example, built as a reusable spreadsheet, is available as the job cost sheet template in Excel, and a packaged version with the quoted-vs-actual comparison built in is available in the Job Costing & Quoted-vs-Actual Workbook for shops that want to start doing this by hand before evaluating a system.
Putting the Method Into a System
Everything above can be done in a spreadsheet, and for a shop running a handful of jobs a month, it's a reasonable place to start. It stops scaling the moment a shop is running dozens of jobs concurrently across multiple work centers, because the spreadsheet has no way to capture actual labor at the operation level as it happens — someone still has to transcribe it from paper, after the fact, which is where the granularity this method depends on quietly disappears.
This is the specific gap WorkTickets is built to close, and it's worth being precise about what that means. WorkTickets is a standalone, SaaS-native execution-and-costing layer — not an ERP, and not a scheduling or inventory system. It builds the routing per part number, generates the traveler (printed with a barcode or digital on a tablet), and gives operators a one-tap kiosk or mobile clock-in with setup/run/waiting/rework reason codes — which is Step 2 of this method, captured live instead of reconstructed later. Actual-vs-quoted labor per operation and per job is available on every tier; work-center burden-rate configuration and a job-level profitability summary — Steps 3 and 4 — are available starting on the Professional tier. Scrap and rework logging tied to the causing operation, Step 5, is available on every tier as well.
That's the full method from this article, running as a system instead of a reconstruction project: four tiers at $199, $349, and $599 a month self-serve, plus an Enterprise tier starting at $1,199/month for shops that need it, and a 14-day trial to run the method against your own jobs before committing to anything. For a broader view of how this fits into running a whole shop's execution and costing — not just one job — the small job shop execution and costing guide and the job costing resource hub both go wider than this single method. And before signing up for anything, the ROI calculator is a reasonable way to check whether the math in this article is worth the subscription for your specific shop's job mix.
