Chasing invoices is the worst chore in any services business: it’s awkward, it’s repetitive, and every hour spent on it is an hour not spent on work that makes money. It’s also the single most automatable business process we’ve ever deployed — after two years of running this exact sequence, here’s the complete setup, including the skip-rules that took us a few failures to learn.

Why this beats the accounting software’s built-in reminders

QuickBooks and Xero both send reminder emails now, and if their defaults fit your business, genuinely: use them and stop reading. You build the custom version when you need what the built-ins can’t do:

  • Per-client schedules — the client who pays on the 15th without fail doesn’t need a reminder; the client who’s chronically 30 days late needs a firmer tone
  • Escalation to a human — the final notice should Slack your account manager, not just email the void
  • Cross-system actions — pause work, flag the CRM, note the account — reminders that actually change state
  • Custom tone — your voice, not the software’s

The sequence we run

Timing Tone Content
Due date - 3 days Friendly “Just a heads-up” + payment link
Due date + 7 days Polite “Appears to have slipped through” + payment link
Due date + 14 days Firm “Payment now overdue” + late fee per contract + link
Due date + 30 days Final Formal notice + “next steps” (collections mention) + Slack alert to owner

Four touches. Enough to collect; few enough to preserve relationships. The sequence stops the instant an invoice is marked paid — which brings us to the part everyone gets wrong.

The one rule that makes it work: check before every send

Every reminder step is conditional on invoice status still unpaid at send time, re-checked live from the accounting system — not assumed from the schedule. This sounds obvious and is the most common failure we see in DIY versions: someone builds “day+7 → send reminder” and a client who paid on day+2 gets a “your invoice is overdue” email for an invoice they paid three weeks ago. Nothing destroys the professional feel of a reminder system faster.

In Make: schedule the scenario daily (or use the accounting tool’s webhook on payment), search for invoices status = unpaid AND due_date = today-7, and send to the results set. The live re-check is inherent — you’re querying current state, not following a stale plan.

Step-by-step in Make

1. Trigger: daily schedule

Scenario scheduled daily at a civilized hour (9:30am your timezone — set it explicitly; the UTC default has burned more people than any other single Make setting).

2. Fetch unpaid invoices

Your accounting tool’s module (QuickBooks Online, Xero, FreshBooks all have native Make integrations): search invoices by status and due-date window. Run four searches — one per reminder stage — or one search returning all unpaid invoices with a router on due-date arithmetic. The router version is one module cheaper per run and easier to read in the canvas.

3. Apply the skip-rules

Before any email sends, filter out:

  • Clients on custom schedules — a tag or note field in the client record (“do not auto-remind”; big clients hate reminder emails and pay on their own clock)
  • Invoices in dispute — an internal status or tag; sending dunning emails on an invoice the client is actively disputing is a relationship fire-starter
  • Government/enterprise PO clients — payment runs on their procurement calendar, not yours; reminders just annoy the AP clerk
  • Invoices already escalated — once a human owns a late account (the +30 alert fired), the machine’s job is done

These four filters took us months and a few embarrassed apologies to assemble. Copy them for free.

4. Compose with the right personalization

Each reminder email template gets: client name, invoice number, amount, due date, and — the single highest-value token — a payment link. Every additional click between the email and payment measurably reduces collection. If your accounting software supports online payments, the link is built in; if not, a payment-page URL with the invoice number pre-filled works nearly as well.

One tone note from experience: write the first two reminders as if written by a competent, friendly human who assumes the invoice slipped through a busy accounts-payable inbox (it usually did). The firm notices can be firmer, but never insult — these are often the clients you want to keep. Our final-notice template literally includes the sentence “If this has already crossed in the mail, our apologies” — it has saved goodwill more times than we can count.

5. The +30 Slack alert

Final reminder day → Slack message to the account owner with client, amount, days overdue, and the client’s payment history summary. This is where automation hands off to human judgment: the owner decides whether it’s a payment-term negotiation, acollections escalation, or (most often) a two-line email that resolves it.

6. Log everything

Every reminder sent appends a row to a log sheet: invoice, client, stage, timestamp. Two reasons: (1) when a client says “we never got any reminders,” you have receipts; (2) it’s your dataset for tuning — our reminder effectiveness numbers come from this log, and they’re how we decided on the four-stage cadence instead of the five we started with.

A worked example: the design studio’s quarter-one cash flow

The first deployment of this exact sequence was for a two-person design studio — the profile where invoice chasing hurts most, because the person doing the chasing is also the person doing the work, and the awkwardness tax of dunning a client you’ll pitch again next month is real. Their before-state: invoices went out on net-30 terms, the founder sent reminders “when she remembered” (average: day 19 for the first, sometimes day 45 for any follow-up), and days-sales-outstanding sat at 52 on a good quarter.

We built the four-stage sequence on their existing accounting tool, wrote the templates in their voice (they’re unfailingly polite, so their templates read even softer than our defaults — tone is a per-business setting, not a copied artifact), and configured the four skip-rules with their one government client and one client-in-dispute correctly excluded.

The first month caught a bug the parallel run was designed for: their accounting system marked an invoice “paid” when the client initiated a bank transfer, not when the money arrived — so the sequence skipped two reminders for an invoice that was actually still outstanding (the payment eventually bounced). The fix was switching the status check from the status field to the payment-received webhook. That’s the lesson worth the whole worked example: verify what “paid” means in your accounting system before trusting it as a skip condition. Every system has its own semantics here, and the quirk is never documented where you’d look first.

After the semantics fix, the quarter’s numbers: days-sales-outstanding dropped from 52 to 41. Reminder emails sent per month: about 22 across ~35 invoices. The founder’s chasing time fell from roughly 3 hours a month to 25 minutes (reviewing the log and handling escalations). And one finding from the log sheet that surprised her: 60% of late invoices paid within 24 hours of the first reminder — the gentle day-minus-3 one. She found this mildly insulting (“they just… needed an email?”); everyone else should find it reassuring. Most late payment is disorganization, not distress, and a polite nudge at machine speed fixes most of it.

The +30 Slack alert fired twice in the quarter. Both resolved with a phone call that had little to do with reminders — one client had a new AP process and never saw the invoices; one had a genuine cash crunch and negotiated a plan. Both then exited the automation via the skip-rules. That’s the system working as designed: the machine gets the account to a human at the right moment, and the human takes the judgment call.

Troubleshooting checklist

When the reminder sequence misbehaves, check these in order:

  • Symptom: a client got a reminder for a paid invoice. Cause: the “paid” status in your accounting tool doesn’t mean what the automation assumes (see the studio’s bank-transfer bug above), or payment landed between the search and the send without a send-time re-check. Fix: use the payment-received webhook as your status source, and re-query status immediately before the email module — not once per run.
  • Symptom: no reminders going out at all. Cause: usually the search filter — due-date arithmetic referencing the wrong field, or a status filter excluding everything (“unpaid” vs “open” vs “outstanding” naming varies by tool). Fix: run the search manually in your tool’s query builder and confirm it returns the invoices you expect.
  • Symptom: reminders arriving at 6am or 11pm. Cause: the scenario timezone is UTC and you never set yours. Fix: scenario settings → timezone → yours. One dropdown, and the most common “why did it send at a weird hour” ticket we see.
  • Symptom: templates rendering with raw placeholder text. Cause: mapping glitch after a template edit — the email module lost its field mapping. Fix: re-map the variables and send yourself a test email after every template edit, not after the first client receives the raw version.

What this doesn’t cover (on purpose)

  • Auto-late fees — possible to automate the application, but fee rules are jurisdictional and contract-specific; keep a human applying fees, machine applying reminders
  • Collections handoff — at some point an account needs a firm human conversation; automate the escalation flag, not the conversation
  • Payment plans — clients who negotiate terms need manual treatment; the “in dispute” or custom-schedule skip-rules are how they exit the machine’s lane

Cost and effort

The full scenario is ~12 modules, ~4 operations per invoice it touches per day it runs. At 100 invoices a month with realistic late-fraction (10-20%), that’s a few hundred operations — free tier, comfortably. Build time: about two hours including templates and skip-rule setup. Payback: the first invoice that gets paid without your having to write an awkward email — usually within the first week.

Where to take it next

  • Client payment-behavior segmentation — the log sheet gives you per-client lateness stats within a quarter; use them to set custom schedules proactively instead of reactively
  • Pre-work pause integration — for retainer clients, the +14 stage can note the CRM (“flag: 2 invoices overdue”) so account managers walk into status calls informed
  • The positive version — automated thank-you notes on payment, which cost nothing, take ten minutes to add, and land surprisingly well

This is the second automation we deploy for every services client, right after lead routing — because cash-flow problems compound faster than lead problems, and both are fully solvable with an afternoon of setup.