Invoice tracking & tiered reminder engine
In most small businesses the founder is the one who chases unpaid invoices, and it is the task that slips first. This replaces the chasing with a script and a schedule.
- Role
- Design and build
- Stack
- Python, scheduler, SMTP, reporting
- Cadence
- Four tiers, day 3 through day 45
- Result
- Every reminder sent on schedule
Tracking is the easy part
Every business that invoices knows which invoices are outstanding. The number is in the accounting software, correct and up to date, and looking at it takes nine seconds.
What doesn’t happen is the next part. Chasing an unpaid invoice is socially expensive in a way that scales badly:
- The first reminder feels premature, so it goes out late or not at all.
- The second one has to be written from scratch, because nobody keeps a template for being politely annoyed.
- The client you most need to chase is usually the one you least want to annoy, so they get chased last.
- By week six it’s awkward enough that the founder decides to mention it on the next call instead, and there is no next call.
The result is cash flow that depends on somebody’s mood on a Thursday, and a dashboard doesn’t change that.
What I built
A scheduler that watches the invoice ledger and sends a reminder at fixed intervals past due, escalating in tone by tier, stopping the moment payment lands.
The tiers do the emotional work
Day three is a nudge that assumes the invoice was missed, because it usually was. Day ten is a reminder with the invoice attached again. Day twenty-one is a firm notice with terms restated. Day forty-five stops emailing the client and emails the founder instead, because past that point the decision is commercial rather than clerical.
The escalation is the entire product. A single reminder repeated politely forever trains clients that the deadline is decorative; a sequence that visibly hardens does not, and it does it without anybody having to choose to harden it.
Stopping properly
The failure mode that would kill this in week one is chasing someone who has already paid. Payment state is re-read immediately before every send, not at the top of the run, and anything reconciled in between drops out. Partial payments pause the sequence and flag for a human rather than guessing. A client who has paid and gets chased anyway costs more goodwill than the invoice was worth.
A weekly picture
One summary on Monday: what is outstanding, what tier each invoice is at, what was collected last week, and what crosses into day forty-five in the next seven days. That last column is the one that changes behaviour, because it is the only one that is about the future.
The part you’d be right to argue with
Most accounting platforms have reminders built in. If you already run one, turn them on before hiring anybody to build anything.
- Built-in reminders usually don’t escalate. They send the same polite message on a loop, which is the behaviour that taught the client to ignore it. The tiering is the part that isn’t in the box.
- It reads the ledger, it doesn’t replace it. Nothing here is a system of record. Invoices stay wherever they already live; this is a scheduler with opinions sitting next to them, and it can be removed on any Tuesday without data loss.
What I haven’t solved
The client who reliably pays on day fifty and is worth more than the friction of chasing. The system treats them exactly like everyone else, and the right answer is probably a per-client schedule instead of one global ladder. That is easy to build, but so far it has always turned into an argument about who gets an exception.