The Real Bottleneck Isn't Labor. It's Handoffs.
A founder's view on where field service businesses actually lose time and money.
You can have great techs, a full schedule, and a healthy backlog and still watch margin evaporate. The usual suspects get blamed: labor costs are up, material prices are unpredictable, customers are harder to deal with. All true. But when I talk to owners and ops leads at HVAC, electrical, mechanical, and facilities companies, the losses they feel most acutely aren't in any of those places. They're in the gaps between them.
The gap between the quote and the work order. Between the field and the invoice. Between the timesheet and payroll. Between the change order that got approved verbally and the one that actually got billed. That's where the money goes. Not in big dramatic failures, but in dozens of small handoffs that rely on a human to carry something from one system to another, and occasionally, invisibly, don't.
What a Handoff Actually Costs You
Most contractors think about handoffs as a coordination problem. "We need better communication." But the real cost is financial and it's hiding in the operational mechanics.
Consider a few scenarios that play out at mixed service and project shops every week:
The unbilled change order. A tech identifies additional scope on site. The site super approves it verbally. The tech does the work. The field report goes into one system, the project file lives in another, and the PM who builds the invoice doesn't see the note. The extra work gets done. It doesn't get billed. You find out three months later, if at all.
The invoice that waits on a signature. Work is complete. The job is closed in dispatch. But invoicing runs on a separate rhythm, pulling from a separate tool, waiting for someone to transfer the completion data and attach the sign off. Days become a week. A week becomes two. If you're billing $400K a month and your average days to invoice is 14 instead of 7, that's roughly two weeks of revenue sitting in limbo, permanently, as a structural feature of how you operate.
The double booked crew. Dispatch is working in one tool. Project scheduling is in another (or a spreadsheet). Nobody has a single view of who is where. A crew gets committed to a planned maintenance block and a reactive call on the same day. Someone has to untangle it at 7 a.m. with a customer already waiting.
The expired permit nobody caught. Permits have expiry dates. When they live in a field on a spreadsheet, or inside a folder in someone's email, the expiry date is invisible until the inspector shows up and the work stops.
None of these are catastrophes on their own. Together, across a 50 person shop running a mix of service calls and capital projects, they represent a consistent, predictable bleed.
The Human Middleware Problem
Here's the framing I keep coming back to: in most field service businesses, the "integration" between tools is people. A coordinator re enters a quote into the dispatch system. A PM manually copies field notes into an invoice. An admin pulls timesheet data from one place and pastes it into another for payroll. An accountant reconciles the job cost report because it didn't match what went into QuickBooks.
This human middleware is doing real work, and it feels necessary because without it, things fall apart. But it has three structural problems.
It's slow. Every re key adds time. Every manual transfer is a process that waits on someone's attention.
It's error prone. When humans carry data between systems, things get dropped, miscoded, or interpreted differently by different people. The job that was quoted at one scope gets dispatched at another. The change order that should have been flagged doesn't make it to the invoice.
It's invisible. This is the most dangerous one. When the handoff fails, you often don't know it immediately. The unbilled work doesn't announce itself. The missed follow up on a quote doesn't send you an alert. You discover it in a margin report weeks later, or you don't discover it at all.
A Framework for Finding Your Worst Handoffs
Before you buy anything or reorganize your team, do this audit. It takes about an hour with your ops lead or PM.
Step 1: Map the journey from customer intake to collected payment. Write it out as a simple sequence: inquiry received, quote built, quote approved, work order created, dispatched to field, work completed, sign off captured, invoice generated, invoice sent, payment collected. Don't skip steps.
Step 2: For each step, ask two questions.
- What tool or system does this live in?
- Who is responsible for moving it to the next step?
Step 3: Mark every point where a human carries data from one system to another. Those are your handoffs. Circle the ones where the answer to "who is responsible" is "whoever gets to it" or "it depends."
Step 4: Estimate the frequency and cost of a miss at each circled point. Not precisely. Rough math is fine. If a change order gets dropped once every ten jobs, and your average change order is $1,500, and you run 200 jobs a year, that's $3,000 a year in unbilled work from one single handoff. Multiply across all your circled points.
Most ops leads who do this exercise are surprised by the total.
What Actually Fixes It
The instinct is usually to fix handoffs with more process: more checklists, more meetings, more reminders. That works at the margins. But the structural fix is removing the handoff entirely by having the work happen in a system where the next step inherits the output of the last one automatically.
When a quote gets approved, the work order should already know the scope, the client, and the billing terms. When the tech closes the job in the field, the invoice should be buildable from that data without anyone re entering it. When a permit is attached to a project, the expiry date should surface in a reminder without anyone checking a spreadsheet.
This is what "one platform" actually means in operational terms. Not software consolidation for its own sake, but removing the dependency on human middleware to carry context from step to step.
At PolarPath, this is the specific problem the platform was built around: a continuous workflow from customer intake through quoting, dispatch, field execution, project management, invoicing, and workforce, where each module inherits operational context from the one before it. QuickBooks stays as the accounting system of record (nobody should be ripping that out), but the execution layer, where the business events actually happen, runs in one place instead of six.
The Practical Takeaway
You don't need to restructure your whole business. Start narrower.
Pick your single most painful handoff. The one your ops lead mentions every week. The one where things fall through most often. Map the before and after: what triggers it, who carries it, where it lands, what happens when it doesn't.
Then ask whether the fix is a better process, or whether the process exists only because two systems don't talk. If it's the latter, no amount of additional checklist will make it structurally reliable.
Most mixed service and project shops have three to five handoffs that account for the majority of their margin leakage. Finding them is the work. Once you can see them clearly, the path forward usually becomes obvious.
If that audit surfaces a picture where the handoffs are baked into your toolstack and not just your process, that's the conversation we built PolarPath to have. See how it fits your operation at polarpath.ca.