Your automation has a resignation date
An automation's uptime is decided by whoever authorized it. What Google, Microsoft and Zapier document about owner-tied connections, plus a 15-minute test.
An automation rarely dies because its logic broke. It dies because the account that authorized it was deactivated on a Friday afternoon. The workflow is still there, still enabled, still showing a green toggle. It just cannot get a token anymore, and nothing in the interface says so until a lead doesn't arrive or an invoice doesn't send.
So here is the check that matters more than any audit you'll run this quarter: open your five most important automations and read the identity each one runs as. If it's a person instead of a role, you're not running an automation. You're renting one from somebody's employment contract.
The failure lives in the token, not in the workflow
Google's OAuth documentation lists the reasons a refresh token stops working: the user revoked access, the token went unused for six months, the password changed on an account with Gmail scopes, the admin restricted a requested scope, a time-based grant expired. The error guide for web server applications adds the one that matters for offboarding: invalid_grant can mean "the user account may have been deleted or disabled."
Read that sentence slowly. Nothing about your integration changed. The authorization underneath it evaporated, and your side of the contract had no idea.
Microsoft says it plainly in its own admin documentation. An orphaned flow is "a flow that no longer has a valid owner," and those flows "can fail if they use connections tied to that user account." The remedy Microsoft documents is administrative: identify the orphaned flows, assign new co-owners, update ownership. Notice what that assumes — that someone knows the inventory. In most companies nobody does, because the inventory lives in the head of the person who left.
Zapier documents the same shape from a different angle. App connections can be shared with team members and ownership can be transferred inside a Team or Enterprise account. And the warning is explicit: if you later stop sharing a connection, any published workflow that relies on it pauses.
Three vendors, three different products, one identical conclusion. The uptime of your automation is a property of the credential, not of the workflow.
Where the identity hides
Teams don't lose automations because they forgot to think about this. They lose them because the identity is invisible in five different places, and each one fails on a different day.
| Where the identity lives | What it looks like in practice | What happens on the owner's last day | First question to ask |
|---|---|---|---|
| A personal OAuth grant | "Connect with Google" clicked by whoever built it, using their own mailbox | Token stops refreshing once the account is disabled or deleted | Is the connected address a person or a role? |
| An account-level app token | A scoped private app or API key issued by the CRM admin | Survives the person, dies with the admin account that can rotate it | Who can rotate this without asking anyone? |
| A shared connection inside the platform | A team credential several workflows point at | Keeps running while shared; pauses when the share is revoked | Is it shared on purpose, or only because they were logged in? |
| A secret only one person can read | Password manager folder, notes app, a local config file | Works fine until the first rotation, then nobody can repair it | Can a second person rotate it today, unaided? |
| A bot user with a human's phone | ops@ mailbox with MFA enrolled on someone's handset | Breaks at the next forced rotation or device change | Whose phone receives the code? |
The table is not a security review. It's an availability review. Row one is the common one, and it's the least dramatic: a perfectly reasonable decision — "just connect it with your account, you're the one who'll maintain it" — that quietly attaches a business process to a hiring decision.
The four-line card
Every automation that touches money or a customer should be describable in four lines, stored somewhere the team can read, and written by whoever built it before they move on. Not a wiki page. Four lines.
- Runs as: the identity, by name. Not "the integration user." The actual account.
- Can touch: the systems it writes to, plus the one action that would be expensive if it fired at the wrong moment.
- Success looks like: one real sample of a correct output — the actual payload, row or message.
- If it fails: who gets paged, and the first action they take.
The third line is the one people skip, and it's the one that makes the card useful. A description of success drifts toward whatever the builder remembers. A sample output is falsifiable: either the run produced that shape or it didn't. In client work, the difference between an automation the team can maintain and one they're afraid to touch is almost always whether a golden sample exists.
The stranger test
Fifteen minutes, no tooling, no consultant.
- Pick the five automations the business would notice within a day if they stopped.
- For each, open the connection settings and read the identity — in the tool, not in anyone's memory.
- Check whether that account is still active and whether it belongs to a person.
- Take the one with the least documentation and have somebody who has never seen it disable and restore it in a test environment, using only the four-line card.
If the person has to ask a question, the card is wrong — and you just learned that for the price of a coffee instead of the price of a silent outage in your best month. This is the same discipline behind monitoring automations so failures are visible, applied to the human layer instead of the technical one.
"We'll check the logs" is not a plan
Run history is a retention window, not an archive. Every platform prunes, caps or rotates execution records on its own schedule, which means the evidence of the last successful run can expire before anybody notices that the run stopped. The natural response — "we would have seen it in the logs" — assumes the logs still exist and that someone was looking.
The platform can also remove the automation for you. Microsoft documents that a cloud flow which consistently stays above its limits for fourteen days is switched off by the system. That's a different mechanism from an orphaned connection, but it lands in the same place: an automated decision, taken without a human in the room, to stop doing the thing the business depends on.
Which is why the ownership question and the observability question have to be answered together. A heartbeat with no owner pages a shared inbox nobody reads. An owner with no heartbeat is a name on a diagram.
Migrating from a person to a role
When you fix this, fix it in the order the money moves.
- Inbound capture — forms, chat, WhatsApp, lead routing. This is where revenue enters; a broken connection here is invisible until the pipeline is thin.
- Quote, invoice and collections paths. Failures here are loud but expensive to reconstruct.
- Client-facing notifications and reporting. Bad data outlives the fix.
- Everything else, which is most of the list, and can wait.
The tradeoff is worth naming before someone raises it in a review. Moving to a role identity or a service account removes the per-person attribution: the audit trail changes from "who clicked this" to "what the run logged." That is a real loss for regulated work. The fix is not to keep personal credentials — it's to log the human decision inside the automation, so the question "who approved this change?" still has an answer. That's a design choice, not a compliance miracle.
And if the automation has grown into something with three systems, two conditional branches and a retry loop, the honest answer may be that it shouldn't be a workflow at all. We've argued where that line sits and where the hidden cost of a disconnected chain shows up — the disconnected chain is usually more expensive than the tool you avoided buying.
The question for your next ops review
Ask it once, out loud: which live automation would stop working if one specific person resigned tomorrow?
You'll get a list, and the list is your backlog. Not a theoretical one — the actual order of work, with names attached, for the automations your business is quietly borrowing from someone's employment. If you want a second set of hands on the migration itself, that's the work we do — wiring the workflows to role identities, writing the cards, and leaving the team able to restart what they own. The same discipline that decides whether an automation survives its launch decides whether it survives its builder.
A resignation is the cheapest audit you will ever run. You just don't get to pick the date.
Frequently Asked Questions
Why did our integration stop working the week an employee left?
Because the integration was authorized by that employee's account, not by a company identity. Google documents that a refresh token stops working when the granting account is deleted or disabled; Microsoft documents that a flow with no valid owner can fail once its connections point at a departed user; Zapier pushes any published workflow that relied on a revoked shared connection into a paused state. The workflow logic never changed. The authorization underneath it did.
Does moving to a service account fix the problem?
It fixes the uptime problem and creates an audit problem. A service account keeps running when people leave, but the activity it produces is attributed to the automation instead of to a person. Keep a field in your logs that names the human who approved the change, or you trade an outage for an unanswerable question during an audit.
How do we find the automations already tied to people who have left?
Open the connection settings of each live workflow and read the identity it runs as. That field, not the workflow name, is the inventory. Any connection showing a personal mailbox, a named individual's OAuth grant or a phone number that belongs to a former employee is a scheduled outage with an unknown date.



