The Month Ends Before the Tickets Do

Your invoices go out on the 2nd. On the 2nd, some of the month's tickets are still in trucks.

That's the whole setup. A paving outfit or a pit that invoices monthly closes the books on a calendar boundary, but the paper doesn't respect it. Driver copies from the 29th come back with Thursday's turn-in. A customer-signed ticket from the 31st surfaces in a jacket pocket the following week. The scale's own copies are fine, but the field tickets, the hauling tickets, the ones that ride in cabs, arrive on their own schedule. Every month, a few dozen tickets are dated in one billing period and keyed in the next.

Ask your billing team what happens to those and you'll hear something like "we add them to the next invoice." Ask where that's written down and you'll get a look. The cutoff is a billing rule, arguably the one that touches more tickets than any other, and in a lot of operations it exists only as a habit shared by whoever's keying that week.

The seam has three exits

Follow one ticket through it. Load hauled on the 30th, ticket 20341, $340 at the contract rate. The invoice run happens on the 2nd. The driver turns the ticket in on the 4th.

The clerk now holds paper that belongs to an invoice that already left the building. Three things can happen, and all three happen somewhere every month.

It gets added to next month's invoice. This is the intended path, and it mostly works, as long as the clerk remembers that "September's invoice" now means "September plus two loads of August," and as long as the customer's AP doesn't kick the line back because the ticket date sits outside the invoice period, which some AP systems are configured to do automatically.

It gets billed twice. This one starts with good service. The customer asked for a corrected August invoice, so someone revised it to include the straggler. The paper ticket, its work done, goes back in the stack, and three weeks later it's keyed again into September's batch, because nothing about it says it already billed. Different invoice, same serial. The customer's AP catches it or doesn't.

It never bills at all. This is the quiet exit. August's run assumes anything dated August already went out. September's clerk sees an August date and assumes the same thing. The ticket sits in the file, perfectly legible, while each month politely defers to the other. Nobody decided not to bill it. Both sides decided somebody else had.

flowchart TD
  A["Ticket dated Aug 30 turned in Sep 4"] --> B{"Invoice for August already sent?"}
  B -- no --> H["Bills normally with its own month"]
  B -- yes --> C["Paper waits for September's run"]
  C --> D["Keyed once onto September's invoice: clean"]
  C --> E["Also added to a revised August invoice: billed twice"]
  C --> F["August's run assumed it billed. September assumes the same."]
  F --> G["Never billed"]

Rates change on the same boundary

There's a second thing sitting on the calendar line: your prices. Rate increases and fuel surcharge resets take effect on the 1st, and a customer's negotiated bump starts September 1, the same day the stragglers start arriving.

So a straggler carries two problems, and lateness is the smaller one. A ticket dated August 30, keyed September 5, billed on September's invoice: which rate does it get? The contract says the August rate, because the work happened in August. The system, if the clerk keys it as a September line, applies September's. On an increase, you've overbilled and the customer's AP has a documented reason to short-pay the whole invoice while they sort it out. On a decrease, or on a surcharge that dropped, you've quietly kept the higher number, and that one surfaces later, in an audit, wearing your company's name.

Here's the claim your controller may argue with: the tickets that straddle your cutoff leak at a higher rate than the tickets you lose outright. A lost ticket at least has a constituency. Drivers know paper goes missing, and clerks chase sequence gaps precisely because everyone agrees a lost ticket is a problem. The straggler has no constituency because it isn't missing. It's in the file, and every count you run says it's handled. Counting tickets can't find a ticket that's present and billed zero times, and it can't flag one that's present and billed twice under two different months. The seam defeats the count.

Put a number on the exposure. A mid-sized operation running 1,800 tickets a month with a monthly invoice run might see 40 tickets a month arrive after cutoff. Say the habit handles 38 of them cleanly. Of the other two, one bills twice and comes back as a credit memo, an apology, and an hour of cleanup. The other never bills: $340 gone. Run that pattern twelve times and the quiet one alone is over $4,000 a year, from a boundary that shows up every month and gets zero minutes of process attention.

Write the seam down

The fix is to write the cutoff down as a rule with parts, not a date on the calendar. A complete version answers four questions in writing. When does the period close? What happens to a ticket dated inside a period that closed? Which rate does a straggler get, the ticket date's or the keying date's? And how does a ticket prove it already billed?

That last one is the load-bearing answer. A paper ticket carries no memory of what's been done with it, which is why the same serial can bill twice and why two months can each assume the other billed it. Once tickets are digitized at turn-in, the serial has a history: keyed on this date, billed on this invoice. A straggler gets flagged for what it is: a ticket whose date precedes an invoice run it missed. The billing rule decides what happens next, always the same way: it bills at its ticket date's rate, on the next invoice, with its August date right there on the line so the customer's AP knows what it's looking at. A serial that already sits on an invoice can't be keyed onto a second one. And the invoice total gets assembled from tickets whose history says they've billed exactly once.

None of that requires software to start. It requires a meeting short enough to hold standing up: pick the answers to the four questions and tape them to the wall where the keying happens. The version with Termco behind it just makes the rule self-enforcing, because the tickets remember.

There's a check you can run this week. Pull last month's invoice and this month's, and look for lines whose ticket date belongs to the other one. Zero such lines doesn't mean your seam is tight. It may mean your stragglers are taking the quiet exit.

If you'd rather have a second set of eyes, send 10-20 sample tickets to hi@termco.ai, including a few dated near your cutoff, and we'll send back what we find within 48 hours.