When an automation goes quiet, is that good news?

The quarterly compliance report didn’t land. That was the whole event. No error, no alert, no red banner in anyone’s inbox. Just… a Tuesday where a thing that usually shows up didn’t, and it took a while for anyone to notice, because the piece of software whose job was to tell us it hadn’t shown up was the same piece of software that hadn’t run.

I keep coming back to that shape. The silence looked exactly like success.

The empty inbox problem

Here is the specific trap. You build a flow in Power Automate to watch something, produce a report, and email it out on a schedule. Hourly, that flow runs constantly and stays warm. Quarterly, it sits idle for weeks at a time, and at some point the platform decides an idle flow is a dormant flow and stops honoring the trigger until somebody logs in and pokes it. I’m going to keep the exact window out of this because the number matters less than the shape: sitting idle can put a flow to sleep, and a sleeping flow doesn’t announce that it’s asleep.

So no error email arrives. The flow that would have sent the error email is the flow that didn’t run.

No report lands. The flow that would have built the report is the flow that didn’t run.

And now here is the thing that got under my skin. An empty inbox in this design reads as “nobody is out of compliance.” What it actually means is “we stopped looking.” Those two states are visually identical from the outside. The audit trail says all clear. The reviewer says all clear. Everyone signs off on all clear. And meanwhile the mechanism that was supposed to distinguish clear from unknown has quietly excused itself from the room.

The same shape shows up everywhere

Once you see it in Power Automate, you start seeing it in everything.

A reporting job tied to one person’s account is fine until that person’s identity changes state. Role change, license shuffle, offboarding, MFA reset that invalidates a refresh token, any of it. The job stops. Nothing about the business changed. The witness changed.

A platform that is the only thing checking whether a platform did its job is a closed loop. It grades its own homework. Whatever it says about itself is what you know about it. Syncs, cron jobs, alert rules, Logic Apps, Zapier zaps, a scheduled PowerShell task on a server nobody remembers is a server. Different logos, same failure mode.

I want to be clear that this is my read of work I’ve actually done and watched break, not a citation of somebody’s research. But I’ve stopped being surprised by it, which is its own data point.

A heartbeat is a second witness

The design answer, and I say “answer” loosely, is a heartbeat. A separate signal from a separate place, confirming two things: the automation ran, and it produced actual output. Not “the flow exists.” Not “the connector is authorized.” Ran, and produced.

The awkward part is the cadence. If the audit is quarterly and the heartbeat is quarterly, you learn about the outage a quarter late, which is roughly the same as not learning about it. So the heartbeat has to fire more often than the underlying process needs, which means you’re now generating a signal that is mostly boring on purpose. Which means somebody has to throttle it, or you’ve built a new form of noise. Digests, thresholds, a channel where a sudden silence would actually get noticed by a human being who is paid to notice.

And the witness has to live somewhere other than the system being watched. Otherwise you’re back inside the closed loop, and the second witness is really just the first witness wearing a hat.

In my experience, the honest version of this is: pick a place you already look at every day, and make the heartbeat go there. If it lands in a mailbox nobody opens, you have not solved the problem, you have moved it.

The maintenance tax I didn’t price in

I want to say something about my own head on this, because it changed.

Going into most automation work, I believed the whole point was to reduce the amount of attention a process demanded. Take the repetitive thing off the human’s plate. Free up the calendar. Win.

What turned it, for me, was building the infrastructure behind Noetis. Workers, database migrations, scheduled jobs, the whole apparatus that was supposed to make the analysis effortless. And what kept breaking was not the analysis. It was the automation of the analysis. The retries, the timeouts, the auth tokens, the queue that got wedged on a malformed input three weeks ago and quietly stopped processing anything new.

The lesson I keep re-learning: automating a poorly understood process does not clean it up. It encodes the confusion and runs it faster, in a place where you can no longer see it happening. I’ve since built the property-management reporting work the other way around, reproducing the manual reports by hand first so I actually understand what the humans were doing, and only then automating what turned out to be real.

Every automation ships with a second, quieter job attached. Somebody now has to watch the automation. That job never appears on the ROI slide.

Responsibility moves, it doesn’t leave

Here is where I’ve landed, and I don’t think it fully resolves.

When you automate an audit, you stop being the person who runs the audit and you become the person who notices when the audit stops running. That second job is smaller, quieter, less visible on any dashboard, and much easier to skip. Which is exactly why it gets skipped.

I’m stuck on this one, honestly. The tension between automating a thing and continuing to watch the thing is real, and I don’t think there’s a version of the architecture that makes it go away. You can make the watching cheaper. You can make the silence louder. You can put a second witness outside the loop. What you can’t do is hand off the responsibility entirely, because somebody still has to notice when the second witness goes quiet too.

Every automation you add is another silence you’ve now signed up to learn how to read. So the honest question isn’t whether the automation is working. It’s whether you’d know if it stopped.