Closing and Recalls

Closing a job creates the invoice, locks the attachments, and ends the record for that visit. Recalls — the return-visit problem — should almost always be a new job rather than a reopened one. Here's the rulebook.

Updated 16 hours ago 3 views jobs closing recalls warranty callback

Closing and Recalls

Closing a job is the moment the system flips from "operational" to "billable." An invoice is created (or extended), the attachments and time logs lock in, the customer gets notified, and the tech's metrics update. Done well, closing is a five-second moment that produces a clean record of what happened. Done poorly, it creates billing problems, missing records, and customer disputes that take hours to untangle.

This article covers the closing flow, what happens automatically, and the surprisingly thorny question of how to handle a customer who calls you back two weeks later because the work didn't take.

When you'd close a job

  • The tech finished the work and the customer is satisfied.
  • The work was performed but the customer asked you to stop part-way and you've billed for what was done.
  • The estimate was rejected and there's no follow-up — close as Cancelled, not Complete (see below).
  • The job was created in error and never communicated to the customer — delete it, don't close it.

When you'd create a recall instead

  • A customer calls you back about previously-closed work that "still isn't right".
  • A warranty issue surfaces on equipment you installed.
  • A part you replaced fails again within the warranty period.
  • A previously-completed visit needs a follow-up that wasn't planned at the time.

The instinct to "just reopen the old job" is wrong. Read on.

Closing — what happens automatically

When a job moves to Complete, several things happen in roughly this order:

  1. The job's status moves to whatever your account has set as the closed/complete state. The change is logged with the user, time, and any comment.
  2. A draft invoice is created (or items are added to an existing draft). The invoice pulls items from the job's parts/labor lines, the recorded time entries, and the appropriate tax categories. See Estimates vs. invoices for the distinction.
  3. Attachments lock in. Photos, signatures, and other files captured during the job become the permanent record of the visit. New attachments can still be added later (e.g., a follow-up photo), but the existing ones can't be quietly swapped.
  4. Notifications go to the customer if your account has auto-notifications turned on (e.g., the invoice is sent automatically on completion). See Job statuses and what each one means for the full list.
  5. The dispatch board drops the job from active rows. It still appears in account history and reports, but stops cluttering the operations view.
  6. Tech metrics update. Daily/weekly counts of completed jobs, average ticket size, etc., reflect the new completion.

Once all of that has happened, undoing it is harder than not doing it in the first place. So before you close a job, double-check:

  • Are all parts and labor lines in?
  • Is the time entry accurate?
  • Did the customer sign off?
  • Are the photos actually uploaded (not still queued on the tech's phone)?

A tech who closes a job in a hurry and then realizes they forgot to add a $400 part has just made a $400 invoice-correction problem.

The closing flow in practice

The typical sequence:

  1. Tech finishes the work. All physical activity is done.
  2. Tech logs final parts and labor on the job. Most accounts expect this on-site, while details are fresh.
  3. Tech captures the closing signature from the customer, ideally with the bill total visible so the signature also acknowledges the amount (see Job attachments — photos and signatures).
  4. Tech marks the job Complete. All the automatic things above happen.
  5. Office reviews the resulting invoice before it goes out. Many accounts auto-send; some hold for review. Either is reasonable, but be consistent — flipping back and forth confuses customers expecting a particular cadence.

For high-trust, repeat customers, you can streamline this — pre-authorized billing with a card on file means the invoice creation, send, and payment all happen in seconds after the close. See Saved payment methods and when to use them.

A job's timeline shows every status change, including the close — the audit trail you'll thank yourself for keeping later

Cancelled vs. Complete vs. Deleted

These three are not interchangeable.

  • Complete — work was done, billing happens, customer-facing record stands.
  • Cancelled — work was not done, but the job exists in the customer's history. No invoice. Use this when a customer cancels, when you decide not to take the job, or when an estimate was declined. Cancelled jobs are part of the customer's audit trail and feed certain reports (cancellation rate, lost-opportunity analysis).
  • Deleted — the job never should have existed. Created in error, duplicate, test job. Removes the row from the system. Use sparingly.

If you're unsure: cancel rather than delete. A cancelled job is recoverable and explains itself ("we agreed not to do this work"); a deleted job is gone.

Recalls — the return-visit problem

A "recall" or "callback" is when a customer comes back about previously-closed work. The natural instinct is to "reopen the old job and add the new visit's stuff to it" — but this is the wrong move almost every time, for several reasons:

  1. The old job has a closed invoice. Adding new line items to an old invoice is messy at best, illegal at worst (depending on jurisdiction and accounting policy). If the old invoice is paid, the system probably won't let you reopen the job at all.
  2. The audit trail collapses. Reading "the tech was on-site Monday and Wednesday" with one big appointment is misleading. Two distinct visits should look like two distinct visits.
  3. Reporting breaks. Recall rate, recall revenue, and warranty cost reports all depend on recalls being separate jobs that reference the original. Lumping them in destroys those numbers.
  4. The new work might warrant different billing. The original might have been billable; the recall might be free under warranty. Mixing them on one record makes "what was this customer charged?" impossible to answer cleanly.

So: a recall is always a new job. What you do preserve is the link.

How to create a recall

The pattern:

  1. Open the customer's account and find the original job in the Jobs tab.
  2. Create a new job of type "Recall" (you set this up in Setting up job types — every shop should have a Recall type).
  3. In the new job's summary, reference the original by job number: "Recall on Job #1247 — return visit for the same compressor that failed on the original install."
  4. Add a tag like "Warranty" or "Goodwill" indicating the billing posture for this visit.
  5. Schedule and dispatch normally. The recall job goes through the same flow as any other job — scheduled, in progress, complete.
  6. Bill (or don't) explicitly. If it's a warranty visit, mark the invoice as $0 or flag it as warranty for reporting. Don't just "not generate an invoice" — the explicit zero invoice is the audit-trail evidence that you considered it and decided not to charge.

When you reach for "is this a recall or a new issue?", the question is "is this work directly remediating something we already did?" — yes means recall. If a customer who had AC service three months ago now has a separate plumbing problem, that's a new job, not a recall.

When reopening is the right move

There are narrow cases where reopening the original job genuinely is correct:

  • The job was marked Complete in error and the work was never actually done. Reopen, finish, re-close. Don't create a duplicate.
  • The tech accidentally closed before adding a critical part to the invoice and the invoice is still in draft (not sent, not paid). Reopen, add the part, re-close.
  • The closing was less than an hour ago and the customer immediately noticed something was wrong before any invoice or notification went out.

In all these cases, the closing was premature, not separate. If the work and the close were both legitimate at the time and now there's a follow-up issue, that's a recall, not a reopen.

Common mistakes

  • Closing a job before all parts are logged. Then the invoice is short, the tech has to amend it, and the customer sees two charges (or worse, the second charge slips through and you eat the cost). Close after the paperwork is done.
  • Reopening a closed paid job. The system will probably block it; if it doesn't, you've created an accounting mess. Create a new job instead.
  • Not having a "Recall" job type at all. Then recalls hide under "Service Call" and your warranty/recall metrics are wrong. Add a Recall type before you have your first recall.
  • Treating "Cancelled" as "Deleted, but I'm afraid to delete". Cancelled means "we considered doing this and decided not to". If a job was never communicated to the customer and was a clerical mistake, delete it — Cancelled clutters the customer's history.
  • Closing on behalf of a tech who hasn't reported in. The dispatcher closing from the office "because Carlos finished an hour ago and forgot to update" strips the time-and-place audit trail. Either teach Carlos to close his own jobs or create a policy that says office-closes are explicitly second-hand and dated accordingly.
  • Forgetting the customer signature on the close. The signed completion is what protects you in disputes. Train techs that "the job isn't closed until the customer signs."
  • Marking a closed-by-customer-cancellation job as Complete. "We were going to do the work but the customer cancelled" should be Cancelled, not Complete with a $0 invoice. The two flow into different reports.

Related articles