The most expensive hour on the clock

Overtime is the labor you pay a premium for, and in most field operations it's the line nobody actually manages. The payroll run shows the time-and-a-half total, somebody winces, and the cost gets filed under "busy season" — as if it were weather instead of the predictable output of how the operation runs. But every overtime hour is a regular hour that something pushed past the end of the day, and the somethings are almost always fixable. Overtime isn't a volume problem you solve by capping the work or sending techs home with jobs unfinished. It's a structure problem — and structure is something you can change.

The trap is treating overtime as a discipline issue ("techs are milking it") or an inevitability ("we're slammed, what can you do"). Both lead nowhere. The operations that actually bring overtime down do it by finding where the extra hours are born and closing those specific holes — most of which are the same holes that cost you margin everywhere else.

You can't manage what you can't attribute

The first failure is that most operations see overtime only as a lump on the payroll report — a total, weeks after the fact, with no idea which jobs, which techs, or which days produced it. A lump you can't act on. The number that matters is overtime attributed: which job ran the tech past the line, which day's schedule blew up, which tech is consistently over and why.

That requires labor time that's captured against the job as it happens, not reconstructed Friday from memory — the same honest labor capture that fixes payroll and costing. In Hosting Field, the job's status timestamps (en route → on site → complete) and the on-job clock-in/out record the real time each job took, attached to the job and the tech. So when overtime shows up, you can trace it to its source — the job that ran two hours long, the day with three emergencies stacked on a full board — instead of guessing. Attribution turns overtime from a mystery total into a list of specific, fixable causes.

Where overtime actually comes from

When you trace it back, the same handful of sources produce most of it:

  • Jobs that run long on a board with no slack. A schedule packed to 100% has nowhere to put an overrun, so the overrun walks straight into overtime. The job that took an hour longer than planned didn't create overtime by itself — the full board behind it did.
  • Windshield time at the end of the day. A last job assigned across town means the tech is still driving at quitting time. Poor routing and zone discipline push the clock past the line with miles, not work.
  • Failed first visits and callbacks. Every repeat truck roll is labor you're paying twice for, and the second roll often lands at the end of a day — in overtime. A callback is frequently an overtime hour in disguise.
  • After-hours and emergency work. Some overtime is real and good — the emergency call that's high-margin and earns loyalty. The goal isn't to kill this; it's to make sure you're pricing it to cover the premium you're paying for it.
  • End-of-day paperwork. A tech finishing the physical work at 5 and then doing an hour of data entry is an hour of overtime spent on a clipboard. Capture the job on-site and that hour disappears.

Notice how few of these are "the tech is slow." Most are scheduling, routing, and process holes — which means cutting overtime and tightening the operation are the same project.

Engineer it down at the source

Each source has a structural fix, and none of them require telling a tech to leave a job half-done:

  1. Build slack into the board. Leaving 15–20% of each tech's day unbooked gives overruns somewhere to land that isn't time-and-a-half. The same buffer that absorbs emergencies and prevents double-booking is your first overtime defense.
  2. Sequence the day to end near home. Route so the last job is close to where the tech wraps, not across the territory. Cutting end-of-day windshield time directly cuts the driving-past-quitting-time overtime.
  3. Fix the first visit. Every first-time fix you improve is a callback you don't run — often the exact callback that would have become an overtime hour. Better intake, smart truck stock, and skill-based dispatch all pay back in hours you don't have to pay a premium for.
  4. Kill the after-hours paperwork. Mobile work orders that capture photos, parts, labor, and sign-off on-site mean "complete" means done — not done plus an hour of evening data entry on the clock.
  5. Price the overtime you choose to keep. The emergency and after-hours work that genuinely needs overtime should be priced to cover the premium. Overtime that earns good margin is fine; overtime you're eating because the quote didn't account for it is not.

Don't cap your way into worse problems

The tempting shortcut — a hard overtime cap, "everyone's out by 5 no matter what" — usually trades a visible cost for invisible, larger ones. A tech sent home mid-job leaves a customer unfinished (a blown promise and a callback). A blanket no-overtime rule on a slammed week means turned-away emergencies, which is high-margin work and loyal customers handed to a competitor. And capping hours while leaving the causes untouched just converts overtime into rushed work, skipped steps, and the callbacks that cost more than the overtime did.

There's also a culture cost to getting this wrong. Techs read an overtime crackdown as "the company cares more about the payroll line than about me finishing my job right" — and that resentment feeds the turnover that's far more expensive than any overtime bill. Frame it correctly: you're not cutting their hours, you're fixing the chaos that creates the bad overtime, so their days end on time because the work fit, not because they were sent home with it undone. That's a better job, and it's the version that actually sticks.

What to measure

  • Overtime as a share of total labor hours — the headline number, but only useful once you can break it down. A flat total hides everything.
  • Overtime by cause — overruns, end-of-day drive, callbacks, after-hours, paperwork. This is where the attribution pays off; you can only fix what you can name.
  • Overtime by tech — segment it, but read it honestly. A tech consistently over is usually getting handed the hard jobs or the bad routes, not slacking. The pattern points at the schedule, not the person.
  • Margin on overtime work — the after-hours and emergency hours you keep should be carrying their premium. If they're not, your pricing is subsidizing them.

Overtime feels like the cost of being busy, which is exactly why operations tolerate it instead of tracing it. Attribute it to its real sources — the slack-less board, the cross-town last job, the callback, the evening paperwork — and close those specific holes, and the most expensive hour on your clock shrinks without anyone going home with a job unfinished. You don't cap overtime down. You engineer it down.