Where the Human Sits in an Automated Workflow

A few weeks ago I wrote that every automated workflow needs a human owner. That’s easy to say and harder to do, because the obvious way to keep a person involved is to make them approve every step, and nobody keeps that up for long. Within a month the approval becomes a reflex, and you have the cost of a human in the loop with none of the benefit.
So this post is about where the person actually belongs. I’m going to use a real example: the pipeline that publishes the posts on this site, including this one. It’s small enough to describe in a few paragraphs and it has broken in enough interesting ways to be useful.
What the pipeline does
There are two workflows, both built in n8n, an open-source automation tool that strings steps together.
The first takes a finished post and puts it on the calendar. It generates a featured image, adds the title to it, uploads it to WordPress, creates the post as scheduled (never published), sets the SEO fields, reads the post back from the server, and checks the stored version against what was sent. If every check passes, it files a note in my notes vault and sends me a message on Telegram. If any check fails, it pulls the post back to draft and sends me the full report.
The second handles social media. It takes the copy for LinkedIn, X and Facebook, schedules all three through Buffer for two hours after the article goes live, and then checks what Buffer actually did.
Neither workflow writes anything. The only AI model call in either one is the image. The text is written and reviewed before it ever reaches the pipeline, and the pipeline’s job is to move it into place without changing it and to prove that it did.
That’s the first decision worth copying: keep the generating and the moving separate. A step that creates content needs judgment. A step that moves content needs to be predictable. When the same step does both, you can’t tell which part went wrong.
The person doesn’t approve each step
Nobody clicks “approve” between the image upload and the post creation. That would be the approval-as-reflex problem.
Instead, the human is in three places.
Before anything runs. Topics, dates, the draft and the social copy all get decided in advance and written down in one reviewable document. By the time the pipeline runs, there’s nothing left to decide. It’s transcription.
At the guards. Some outcomes are made impossible rather than checked for. The publishing workflow has no code path that publishes immediately; it can only schedule or save a draft. It refuses any scheduled time less than an hour away. It refuses content with broken formatting before it touches WordPress at all. A person decided those rules once, and the workflow enforces them every time.
When something fails. Failures go to my phone with enough detail to act on. Success is quiet apart from a short confirmation.
That’s the pattern I’d recommend for most business automation. People make the decisions up front, write the rules that should never be broken, and handle the exceptions. The machine does the repetitive middle part and reports honestly on how it went.
The word “honestly” turns out to be doing a lot of work.
Everything reported success
Here are some of the ways this pipeline, and the tools around it, have failed. None of them were caught by the tool’s own status.
Buffer returns success when it fails. Buffer’s API returns an HTTP 200 (the standard “everything’s fine” response) even when the request was rejected for a validation error. An automation that trusts the response code reports a clean run while creating nothing. The social workflow now reads the body of every response and sorts it into six possible outcomes, because “200” alone means almost nothing.
A remote command failed and the step passed anyway. The step that files the note in my vault runs a command on another machine over SSH. On the first test the command didn’t exist on that machine. The remote side returned an error code. The n8n step reported success, because by default it only cares that the SSH connection worked, not whether the command did. A separate check now fails the whole run on any non-zero exit code.
WordPress skipped scheduled posts. WordPress publishes scheduled posts using a built-in task runner called WP-Cron, which by default only wakes up when someone visits the site. It has missed a scheduled publish on this site twice. The post sat there marked “scheduled” and the URL returned “page not found” on the day it was supposed to go live. That’s why social posts go out two hours after the article instead of at the same moment. A social post that links to a missing page is worse than a late one.
X counts every link as 23 characters. X wraps every link in its own shortener and charges 23 characters for it, no matter how long or short the real address is. Our length counting got this wrong at first, and in one batch four of seven X posts turned out to be over the limit once the link was counted the way X counts it. Every length check in the pipeline now counts links X’s way.
Retrying created duplicates. Buffer quietly refuses a duplicate of a scheduled post, but happily creates a duplicate draft. A retry after a partial failure left two copies of the same LinkedIn draft. Each channel can now be skipped individually, so a retry only touches what actually failed.
The pattern across all five is the same. The tool said it worked. The only way to know whether it worked was to check the thing it was supposed to change.
Check the result, not the report
The publishing workflow’s checks all look at the post as it exists on the server after the fact, not at what the upload step said happened. It confirms the content is byte for byte identical to what was sent, that the formatting is intact, that the status is “scheduled” and not “published,” that the date is right, that the correct image is attached, that the address is what was asked for, that the standard links at the bottom are there, and that the three SEO fields hold the right values.
Every one of those checks exists because of something that went wrong. The byte-for-byte check exists because an earlier post had its content quietly mangled during a routine update. The status and date checks exist because of a bad afternoon in September.
That afternoon was a person, not the pipeline. A WordPress command-line update meant to move five scheduled posts to new dates published all five on the spot instead. The command silently ignores date changes unless you include a specific flag, and if you change the local date without also changing the stored UTC date, WordPress compares the stale one against the current time and decides the post is overdue. Five posts went live days early. That mistake is the main reason the pipeline now refuses to publish anything immediately. It’s much easier to make a bad outcome impossible than to rely on everyone remembering a flag.
The general lesson for any business automation: decide what “done” looks like in terms you can observe, and check that directly at the end. If you’re automating invoices, check that the invoice exists in the accounting system with the right total. If you’re automating user offboarding, check that the account is actually disabled. “The step succeeded” is a claim, and some tools make it whether or not it’s true.
What I’d tell someone building their first workflow
Start with a process that’s repetitive and annoying, where a mistake is visible and fixable. Publishing, reporting, data entry between two systems, collecting evidence for an audit. I wrote about that last one in Automating Compliance Evidence Collection.
Write down, before you build anything, what the workflow must never do. Then build it so it can’t do those things, rather than relying on a check to catch them afterward.
Decide who owns it. A specific person who gets the alert, knows how to read the report, and is allowed to fix it. I made the case for that in Lead AI, Don’t Just Learn It, and this is what it looks like in practice.
Make failure loud and success quiet. If every run sends a long message, people stop reading them, and the failure message gets ignored along with the rest.
Assume the tools will tell you something worked when it didn’t. Not because they’re bad tools; Buffer, n8n and WordPress are all good at what they do. They just report on their own step, and the step was never the thing you cared about.
Keep a written record of what broke and why. Every check in this pipeline traces back to a specific failure, and that list is the most useful document in the whole project. The next person to change the workflow (which might be you in six months) needs to know why each guard is there before they decide it’s unnecessary.
If you run n8n yourself, back up your workflows. A pipeline you can’t rebuild is a single point of failure. I covered one way to do that in Back Up n8n Workflows in Docker.
Where this leaves the human
Automation done well doesn’t remove people. It moves them. In this pipeline the person spends almost no time on the mechanics of publishing and a fair amount of time deciding what to publish, reviewing it, and occasionally reading a failure report and fixing the cause.
That’s a better use of a person than clicking “approve” forty times a week. It’s also more demanding. You have to think up front about what could go wrong, and you have to take failure reports seriously when they arrive.
The workflows that go badly are usually the ones where nobody did that thinking, and the automation runs happily for months while quietly doing something nobody intended. A green checkmark is not proof. Check the result.
Where to go next
- Automating compliance work is a good place to start, but it helps to know where you stand first. The CMMC readiness quiz takes about five minutes.
- Our CMMC guide for small contractors walks through the levels from the beginning.
- Need documentation in place before you automate the evidence behind it? Start with our CMMC packets.
Discover more from CyberCloudAI.tech
Subscribe to get the latest posts sent to your email.