The Load You Sold Yourself

Tuesday at the pit, 63 loads cross the scale. Fifty-nine of them carry a customer and a job number. The other four get keyed to Job 100, the code your office calls company use. Two are real: gravel for the yard road, and a stockpile move from the north bench to the crusher pad. One is your own paving crew, drawing base for a job you bid with material included. And one is a flatbed outfit's ninth load of the day, keyed to Job 100 because the driver couldn't remember the job number, the line was four trucks deep, and the scale operator did what scale operators do: kept the line moving and figured somebody would fix it later.

Nobody fixed it later. There is no later for Job 100.

Watch what happens to the other 59 tickets and you'll see why. Each one becomes a line on an invoice. Your billing office reads it once when the invoice gets assembled, and the customer's AP department reads it again, looking for a reason not to pay it. Two readers, both paid to care. The Job 100 ticket has zero readers. It produces no invoice, lands on no statement, and answers to no AP clerk anywhere. It rolls up into a cost bucket everyone already expects to be fuzzy, because it's just the yard.

That's what makes the internal code different from every other place a ticket can go wrong. A miskeyed customer ticket at least lands in front of someone. Key the Route 9 load to the fairgrounds job and the fairgrounds customer sees a load they never took, disputes it, and the correction hunts down the real job. The error is loud. Key the same load to company use and it isn't an error anymore. It's overhead. The material left the gate, the customer got their base rock, and the $270 it should have billed is now a rounding blur in your cost of doing business.

The code with no resistance

Miskeys don't land on Job 100 by accident alone. They get pulled there, because it's the cheapest exit at the scale window.

Keying a customer load takes work: find the account, find the job, confirm the rate applies. Keying Job 100 takes none. No rate lookup. No callback when the job number doesn't exist yet because the office hasn't set it up. Every point of friction in the real path pushes traffic toward the frictionless one. New job started this morning and dispatch hasn't sent the number? Job 100 for now. Customer's account is on credit hold and the system won't take the ticket? Job 100, sort it out with the office. Scale printer choking during the morning rush? Job 100, and a note that says which truck.

Each of those is somebody being practical. Each one also converts a billable event into overhead, on paper signed by nobody who'll ever check. The tickets that were supposed to be rekeyed sit behind the tickets that arrived clean, and the clean ones never stop coming. A parked ticket with a real customer behind it has a constituency: sooner or later a count comes up short somewhere. A ticket already keyed and counted has none. Every audit you run says it's handled, because it is handled. It's just handled as free.

Put a number on the yard

Here's arithmetic worth running once. Your yard, your roads, your stockpile moves, and your equipment pads consume a knowable amount of material. Not a precise amount, but a knowable one: a pit that grades its haul roads twice a season and tops the scale approach once doesn't need 300 tons of product a month to do it.

So pull the internal tonnage. Say Job 100 took 290 tons last month. Sit down with whoever runs the yard and build the honest estimate of what the operation itself consumed: call it 120 tons of road gravel and pad rock, plus 60 tons of legitimate stockpile moves. That leaves 110 tons keyed to your own name that nobody in the yard remembers using. At a $28 average, that's roughly $3,100 of material that left the gate in one month, with your own job code holding the door. Some of it will turn out to be real internal use nobody logged. The rest is the leak.

flowchart TD
  A["Load crosses the scale"] --> B{"Job number known at the window?"}
  B -- yes --> C["Keyed to the customer job, bills normally"]
  B -- "no: line is moving" --> D["Keyed to Job 100 to fix later"]
  D --> E{"Does anyone reread Job 100?"}
  E -- no --> F["Billable load, filed as overhead forever"]
  E -- "monthly count against expected use" --> G["Miskey caught, rekeyed, billed"]

Your quarry manager will hate this next part: the internal code deserves a harder monthly audit than any customer account you have. Backwards, on its face. Customers are where the money is; Job 100 is just the yard. But scrutiny should follow silence, not size. Every customer account comes with a free auditor attached. The internal account is the one ledger in the operation where a vanished load looks exactly like a Tuesday.

The objection that it's your own rock, so nothing was lost, doesn't survive contact with the ticket. The rock crossed the scale on paper because somebody hauled it somewhere. If it went to your yard, fine, the code told the truth. If it went to a customer's job, the loader time and the haul really happened, and the revenue that was supposed to sit on top of them is the only part that didn't.

Give your own name the same spine

The fix isn't banning the internal code. Yards are real, stockpile moves are real, and your paving crew has to draw material somehow. The fix is making Job 100 carry the same paper a customer would.

Split it in reference data first. One catch-all code is a fog bank. Four named internal jobs are auditable: yard maintenance, stockpile transfer, internal paving, scale testing. Each gets an owner and a rough expected volume, written down where billing can see it, so the monthly count has a benchmark.

Then let the tickets police themselves. A billing rule holds the line the scale operator can't: an internal ticket without a destination on your property gets flagged as non-compliant the day it's captured. Digitize tickets at turn-in and the placeholder trick surfaces on its own, because a Job 100 ticket whose destination names a place you don't own shows its miskey in plain sight. It gets caught that week instead of graded into the haul roads at year end. Invoice totals get assembled only from tickets that priced against a rule, and the internal codes go back to being a record of what the operation consumed, not a drawer where billable work goes to rest. That machinery is what Termco builds: the tickets captured, the odd ones flagged, the rules and reference data structured, the totals assembled from nothing else.

The audit takes one afternoon. Pull 90 days of internal-code tickets and read the destination on each one. Count how many name a customer's site, a public road job, or nothing at all. Then price that count at your average ticket. If it comes back zero, this wasn't your leak. If it doesn't, you've just priced it yourself, off your own paper.

If you'd rather not read the stack alone, send 10-20 sample tickets to hi@termco.ai, internal-code tickets included, and we'll send back what we find within 48 hours.