Quick one before we start: Build Night with Hefti is on tonight, 6pm London. Come along.
Your blog can publish a post and still leave you wondering whether anything happened. The article exists. The person who needs the link gets nothing.
You've automated the writing, but you're still checking the website yourself. That's an odd place to stop.
This week we merged a change to my own site to close that gap: a publish notification that can tell Hefti when a new article goes live. You don't need to care about blogging to recognise the problem. You've probably got an invoice, report or booking process with the same missing last step.
The build merged on Tuesday. The source code and tests show what it does; they don't, on their own, prove a notification reached Slack. That distinction matters. Here's the change, the limits, and what I'd check before calling the whole thing finished.
The gap nobody sees
Most automation stories stop at "it works." The post publishes. The email sends. The job runs.
But a job finishing and a human knowing about it are two different things. If the only way to learn a post went live is to go and look, you've built a system that needs a babysitter. You've just moved the babysitting from writing to checking.
I've written about this before. A report once told me an email job had skipped four and errored zero, when it had sent nothing, ever. The lesson stuck: a system you can't hear from is a system you can't trust. I wrote that one up here.
This was the same itch from the other side. Not "is it broken?" but "did it happen?"
What I actually asked for
The merged pull request came from Hefti's code runner, the bit of Hefti that reads a repo, makes a change and opens a pull request for me to review. The brief was one paragraph of goal and six numbered points. Short version:
- When a post goes from draft to published, send a webhook to Hefti.
- Include the post ID, title, excerpt, the featured image link, the full live URL and the publish time.
- Run after the featured-image step. If image generation fails, allow an announcement without a picture rather than lose the notification.
- Fire on the first publish only. Edits and re-saves send nothing.
- Never hardcode the destination or the secret. Both live in environment variables.
- If the webhook fails, the publish carries on regardless.
Then a "done when" line, which I'll come back to, because it's the bit most people skip.
The three rules that matter
Anyone can bolt a webhook onto a publish button. The value is in what you stop it doing. Three rules did the heavy lifting.
1. It attempts the announcement once. A publish flow gets touched constantly. Typo fixes, new tags, a tweaked excerpt. If every save pinged the team, you'd train everyone to ignore the pings inside a week. So the trigger is the first flip from draft to live and nothing else. The build adds a small marker in the database before the send, so another call won't start a second attempt.
2. It signs what it sends. If a secret is set, the body is signed with an HMAC and the signature goes in a header. That means the receiving end can check the message really came from my site and not from some random bit of the internet poking at a public address. But the receiver needs to verify that signature. Adding a signature at the sending end isn't the same as checking it at the other end.
3. It can never block the publish. This is the big one. The webhook has a timeout of around five seconds, and if it fails, it logs the error and moves on. The post still goes live. A notification is a nice-to-have. The post is the product. If the announcement system falls over at 5am and takes the blog with it, I've made things worse than before I started.
That third rule is the difference between an add-on and a liability. Always ask of any new automation: when this breaks, what does it take down with it? The answer should be "nothing but itself."
What was in the pull request
I'm not going to pretend this was glamorous. The merged change included:
- A shared module that builds the payload and sends it
- Hooks in the three places a post can get published: the daily auto-blog job, the manage-posts function and the admin screen
- A small function that handles the announcement
- A database migration for the "already announced" marker
- Two new lines in the example environment file, with comments, so future me knows what they're for
- A short setup note in the README for Vercel
- A test file covering the payload shape
The test file is the part I'd push anyone to ask for. It uses a fake database and a fake sender to check the payload, the once-only behaviour and what happens when sending fails. It doesn't publish a real article or prove that Slack received anything. Those are the same three rules, written as checks. If someone changes the code in six months and breaks one, the tests say so.
The "done when" line
Here's the line I put at the bottom of the brief:
"Done when: publishing a draft sends exactly one POST with the payload above, edits send nothing, and a webhook failure doesn't affect publishing."
That's it. Three things, all testable, none of them vague. Compare that with "make it send a notification when posts go live," which is how most people brief an AI and then wonder why the result is half-right.
A brief without a finish line gets you something that looks finished. A brief with one gets you something you can verify in two minutes. I'd rather spend my time on the second.
What the code does, and what still needs proving
In the site's MCP publish path, the article goes live first. The featured-image request runs in the background, then the announcement helper runs. If the image step fails, the payload can contain no image. That's different from promising a picture every time.
The helper needs a destination configured before it sends anything. Signing needs its secret configured as well. With no destination, it returns without sending. So a merged pull request isn't evidence that anyone has received an announcement.
And there's a trade-off in that once-only marker. The code claims the post before attempting delivery. If the receiver is down, it logs the failure, but a repeat publish won't automatically try again. You've avoided duplicate pings; you haven't built guaranteed delivery.
For a blog announcement, keeping publication independent may be the right choice. For an unpaid invoice or an urgent customer alert, I'd want failed attempts visible and a deliberate retry process. The consequence decides the design.
Before calling this connected from start to finish, I'd publish a test, check the receiving log, confirm the message arrived, then edit the article and check that no second announcement appeared. Until that check passes, it's a merged build with tests, not a proven live Slack workflow.
Review it before you merge it
One thing I'll be straight about. The pull request was written by Hefti. I've checked its source and tests for this write-up. The summary on the PR said "No summary written," which tells you the automation isn't perfect at describing itself. The tests cover specific behaviours. They don't prove the live destination is configured. Review the work, not just the write-up.
I'd also say don't skip the boring parts of a build just because the AI will happily skip them for you. The env var comments, the README note, the test. That's the stuff that makes it survivable when you've forgotten how it works in three months' time.
The takeaway
Automation that runs but never reports back is only half built. If you've got something that does its job overnight, ask yourself how you'd find out it happened. If the honest answer is "I'd go and look," you've got a task left.
Fix it with three rules:
- Choose the right event, and decide how retries should work.
- Sign the message and check the signature at the receiver.
- Make sure it can never take the real work down with it.
Then write the finish line before you start, not after.
Sources
- My own build: merged publish-webhook change, pull request 397, 17 November 2026. Private repository, so readers outside the project won't be able to open it. I checked the implementation and its test file for this article.
- My earlier post on silent job reports: The Report Said Four Skipped, Zero Errors. It Had Sent Nothing, Ever.
Tonight's Build Night with Hefti, 6pm London. We'll review Hefti and talk through the work behind it. If you've got a process that runs but leaves you checking whether it finished, bring that question along. Grab a seat.
#BrewedByStevenPouredByHefti
About Steven Tann: Steven helps business owners build systems that run themselves using AI. After 10+ years helping 7,000+ businesses and building his own autonomous operations, he's the bloke who actually does it, not just talks about it. He's also the founder of Hefti, the AI operating system for small business. Find out more at steventann.com.