← Daily

Problem breakdown · No. 031 · November 15, 2026

Parts used on the job often never reach the invoice

In small repair and install shops, the part pulled from the van is easy to forget by the time the invoice is written. The fix is less about better forms and more about a quick capture step and a reconciliation the office actually trusts.

The problem

A technician on an HVAC, plumbing or appliance call pulls a capacitor, a fitting and some line set from the van, finishes the repair, and moves on to the next job. The invoice gets written later, sometimes by the tech in the driveway and sometimes by the office at the end of the day. The parts that were used are remembered unevenly, and small consumables are forgotten most often.

This costs the shop twice. The forgotten parts are revenue that was earned and never billed. The van inventory also drifts, so restocking is guessed and the next tech runs out of a part mid-job.

Field service management tools already have line items and price books. The gap is not the data model but the moment of capture. Typing SKUs on a phone with dirty hands, in a basement with no signal, is the step that gets skipped, and nothing downstream notices the omission.

Constraints

  • Techs will not type. Capture has to take seconds: a voice note or a photo.
  • Signal is unreliable on site, so capture must work offline and sync later.
  • The shop already has a system of record for jobs and invoices. This must sit beside it, not replace it.
  • API access to that system varies by vendor and plan. A CSV export of the price book may be all there is.
  • Price books are messy: duplicates, vague names, stale prices.
  • A wrong line item becomes a customer dispute. Nothing is billed without a human approving it.
  • Budget is a small monthly fee, and the owner is the only admin.

System design

The flow has four parts.

  • Capture: at job close the tech records a short voice note or photographs part labels and the supply house receipt. The app stores these locally with the job ID and syncs when online.
  • Extraction: a model turns the transcript and images into candidate items: description, quantity, any part number it can read. This is where an LLM earns its place, because the input is unstructured speech and photos.
  • Matching: plain code matches candidates against the price book by part number first, then by a constrained fuzzy match on normalized names. Price, tax and markup come only from the price book. The model never sets a price.
  • Reconciliation: code compares matched candidates with the draft invoice and shows the office a diff: items mentioned but not billed, and items billed with no mention. Approved additions are written back with an idempotency key per job and line, so a retried sync cannot double-bill.

Anything the matcher cannot resolve with confidence goes to the review queue unmatched, never to a best guess.

Trade-offs

This design trusts the tech's note, so a part never mentioned is still missed. That is acceptable because a spoken list at job close is far more complete than a typed one, and van stock counts can catch the rest later.

It adds a review step for the office. I prefer that cost to automatic billing, because one wrong charge erodes customer trust faster than a missed fitting costs money.

Fuzzy matching will be wrong on a messy price book. Routing low-confidence matches to a person keeps errors visible instead of silently priced.

What I would build first

I would start with no integration at all. A simple mobile page records a voice note against a job number. A nightly job transcribes, extracts candidates, matches them against the price book CSV, and produces a review sheet per job listing items mentioned but absent from the exported invoice.

Run it with one shop for two weeks. The only metric that matters is how many approved lines the office adds that would otherwise have gone unbilled. If that number is meaningful, write-back and offline sync are worth building next.

When revenue leaks at a capture step, make capture effortless with a model, but keep pricing and billing in deterministic code behind a human review.