A tech finishes a job at 2:15. He fixed the unit, swapped two parts, spent ninety minutes on site, and got a signature on a paper ticket that's now sitting on his dashboard with a coffee ring forming on it. The office won't see that ticket until he drops the stack on Friday, or until someone calls him to ask what he did because the customer wants to be billed. The dispatcher who needs to know he's free has no idea he's free. The invoice for that job won't go out for nine days. The part numbers on the paper ticket are half-legible. Somebody in the office will reconstruct what happened from a phone call, a smudged ticket, and a guess.
Run a field service operation and this is your whole day, repeated across every tech and every job. The work gets done well. The data about the work arrives late, incomplete, and re-keyed — and that's what costs you.
The office-field gap
There are two halves to a field service business and a canyon between them.
The office plans, schedules, dispatches, and bills. The field executes. Information has to flow both directions across that canyon constantly: the office needs to push jobs out to techs and pull job results back in. In most operations, both directions are broken.
Push is broken because the schedule lives in the office and the tech finds out about changes by phone. A job gets added, a customer reschedules, a priority emergency drops in — and the only way the tech learns is someone calling the truck. The dispatcher spends the morning on the phone being a human message bus.
Pull is broken worse. The tech does the work and the record of it — parts used, time on site, what was found, what was fixed, the customer signature — gets captured on paper or in his head and travels back to the office at the speed of a truck. It arrives hours or days later, smudged and partial. Someone in the office decodes it into the billing system. The decode is lossy: parts get missed, time gets rounded down, the diagnostic notes get compressed to nothing.
The cost shows up in two places. First, billing lag. When the job record takes a week to make it back clean, the invoice takes a week-plus to go out, which pushes your cash collection out by the same amount on every job. For a shop running hundreds of jobs a month, a 9-day average lag is a permanent hole in working capital. Second, the office labor that exists only to translate field paper into office data — chasing techs for missing details, decoding tickets, re-keying part numbers. Two or three days a week of someone's time, $50k to $80k a year, spent on a translation problem that shouldn't exist.
Why this is wiring, not work ethic
The instinct is to blame the techs. Train them to fill out tickets better. Make them call in completions. It never holds, and it never holds for a structural reason: the tech's job is the repair, and every minute you ask him to spend on paperwork is a minute off the job and a worse customer experience. You're asking a skilled tradesman to also be a data-entry clerk, on paper, in the field, and then acting surprised when the data is bad.
The problem isn't that techs are sloppy. It's that capture and execution are separated by design. The work happens in the field; the system that needs the data lives in the office; and the only bridge is paper and memory. No amount of discipline turns paper-and-memory into a clean real-time feed. You can have the most conscientious crew in the trade and the invoices still lag nine days, because the wire from the field to the office is a truck.
Same on the dispatch side. A dispatcher juggling a whiteboard and a phone isn't disorganized — she's compensating, manually and in real time, for the absence of a shared schedule the techs can see. Give the most talented dispatcher alive a whiteboard and a phone and she's still a message bus, because the system gave her no other way to move information to the trucks.
Mobile-first capture, one system
The fix is a single system where the field and the office are the same data, and the field is where capture happens — at the moment of work, not in a Friday reconstruction.
The tech's phone is the system of record, not a paper ticket's understudy. He arrives, the job is already on his device with the history, the address, the equipment, the scope. He logs time by tapping start and stop. He picks parts from a list, not from memory. He captures photos, notes, and the customer signature on the screen. When he marks the job complete, that record is done — structured, complete, timestamped — and it's in the office instantly. There is no paper, no decode, no Friday stack.
Dispatch sees techs in real time. The 2:15 completion shows up on the dispatch board at 2:15. The dispatcher knows that tech is free and where he is, and assigns the next job to his device. The morning on the phone being a message bus is over, because the schedule the office edits is the schedule the techs see.
Billing fires from a complete record. Because the job came back structured and complete — real parts, real time, real signature — the invoice drafts itself from what actually happened the moment the job closes. You review and send the same day. The nine-day lag collapses to same-day, and the translation desk that decoded paper tickets doesn't exist anymore because there's no paper to decode.
Scheduling and billing are one system, not two. This is the part off-the-shelf field tools usually fumble. The schedule, the job execution, and the billing are the same data model, so a completed job flows into a draft invoice without a handoff, and a rescheduled job updates the tech's device and the customer notification at once. No glue, no sync job that silently fails, no < csv > export between two products that pretend not to know each other.
This is also where a custom build earns its keep over a packaged FSM product. The packaged tools assume a generic job shape. Real field operations have their own: specific equipment hierarchies, warranty rules, contract SLAs, multi-visit jobs, parts-on-truck inventory. A custom build models your job, not a vendor's idea of an average one — which is the difference between software your techs use and software your techs route around.
What fixed looks like
Fixed is a tech who closes a job on his phone and is genuinely done — no Friday stack, no callback from the office asking what he did. Fixed is a dispatcher watching a live board instead of working a phone, routing the next job to the truck that just came free.
Fixed is an invoice that goes out the day the work happened, because the work is the record. Your average days-to-invoice drops from nine to one, your cash comes in a week and a half faster on every job, and the working-capital hole closes.
Fixed is the office translation desk reassigned to work that grows the business — because there's nothing left to translate when the field captures clean data directly. Fixed is knowing, at any moment, where every tech is, what they're on, and what's billable from today, without making a single phone call.
This is for you if
You run a field service operation — HVAC, electrical, plumbing, equipment service, facilities, specialty trades — with somewhere from 5 to 60 techs in the field and revenue from $2M to $30M. Your techs capture work on paper or in their heads. Your dispatcher runs the day on a whiteboard and a phone. Your invoices lag the work by a week or more, and you have someone whose job is partly to chase and decode what the field did.
A focused build — mobile capture feeding clean job records into your existing billing — starts around $25k. A full platform unifying scheduling, dispatch, mobile field capture, and billing on one model runs $50k to $100k+ depending on crew size, equipment and warranty complexity, contract/SLA rules, and inventory-on-truck tracking. We open with a scoping session that puts the real scope, number, and timeline in writing before a line of code gets written.
This is not for you if a packaged field-service app already fits your job shape cleanly — if your work is generic enough that an off-the-shelf tool models it without you fighting it, buy the off-the-shelf tool. The custom build pays off when your operation has enough specificity that the packaged products force you to work their way instead of yours, and when the billing lag and the translation desk are costing more than the build. If you're routing around your current software every day, that's the signal.