Back to blog

October 26, 2026

Why Checking a List Once Isn't the Same as Checking It Every Time

We run a system that does the same job for many different customer accounts, on a schedule, with no human pressing a button each time. Some of those accounts are active. Some have been paused by the customer. Some have been shut down entirely. The system is supposed to skip the ones that aren't active.

It worked correctly for a long time. Then we found a gap that meant a paused account could still get processed, and the reason why is worth knowing if you run any kind of automation across more than one customer.

The setup: one job, run across every customer

Think of a system that checks in on every customer account once a day and does something useful with whatever it finds, sending reminders, processing updates, generating a report. To do that job, it needs a list of which customers to run for.

The obvious way to build this is to generate that list once, hand it to the automation, and let it work through each name. That's exactly what we did.

The gap: the list was trusted, but never rechecked

Here's what we missed. The list told the system who to run for. It did not tell the system to double-check, right before doing the work, whether that customer was still supposed to be included.

If a customer was paused after the list was generated, the system had no way of knowing that unless the list itself got updated and that update successfully went through. If the update to the list failed for any reason, the automation simply kept running for a customer who was no longer supposed to be active, because nothing ever asked them again.

This is a subtle gap because it only shows up in a specific sequence of events: a customer gets paused, and the update that was supposed to remove them from the list doesn't land cleanly. The system never fails loudly. It just quietly keeps doing work for someone it shouldn't.

Why this matters more than it sounds

A business owner might read that and think, "so what, one extra customer got processed." But think about what "processed" means here. If the task involves sending someone a message, updating their records, or taking action on their behalf, doing that for a customer who specifically asked to be paused is a real problem, not a cosmetic one. It's the business equivalent of still charging or still emailing someone after they told you to stop.

The deeper issue is that the only thing standing between "paused customer, correctly skipped" and "paused customer, incorrectly processed" was a single update landing successfully somewhere else in the system. That is a fragile thing to depend on for a decision this important.

The fix: check status at the moment of action, not before

The fix wasn't to make the list more reliable. You can always make a list more reliable and it will still eventually be wrong at the wrong moment. The real fix was to stop trusting the list as the final word, and instead check each customer's actual current status right before doing anything, every single time.

Now the system looks at three possible answers every time it's about to act on a customer: run, skip, or something's wrong here, ask a person. "Active" means run. A status the system recognizes as deliberately not running, paused, cancelled, not yet started, means skip quietly, because a customer who asked to be paused isn't a problem, they made a choice.

Anything the system doesn't recognize, a blank value, an unexpected status, something that shouldn't be possible, gets treated as a loud alert, not a quiet skip. That distinction matters a lot. A customer who deliberately paused their account is not an emergency. A customer whose status the system can't even make sense of absolutely is, because the safe assumption in that case is "we don't actually know what's supposed to happen here," and guessing wrong in either direction, running when we shouldn't or skipping when we shouldn't, is a real mistake.

The second bug hiding inside the first fix

While building that fix, we found a second, smaller problem sitting right next to it. When the system checked a customer's status and found they were paused, it was treating that the same way as a technical failure, logging it as "something went wrong," which meant it looked exactly like a broken run even though the system had done the right thing.

That's its own kind of damage. If your automation cries wolf every time it correctly skips a paused customer, you train yourself to ignore its alerts, and the one time it's genuinely broken looks identical to the hundred times it worked exactly as intended.

We fixed that by separating the two outcomes clearly. "I skipped this customer because they're paused, that's expected" is a quiet, successful