Tony Bleything

THE PUBLISHING ENGINE

Drafts in my voice. Ships in my time.

The human gate: the approval queue.

Personal OS

Any publishing queue where brand or regulatory risk sits on the last click.

In finance and legal marketing: Campaign copy drafted in the house voice, links and claims checked, published only after a named approver signs that exact piece.

A pattern, not a past engagement: it describes how this system would be used, not where it has been.

Harvests sourcestiered · vendor-flaggedDrafts posts + visualslinks checked liveStages to the queueduplicate guard, fail-closedTHE GATEI read each postapprovePublished to LinkedInunder my name, by my callor it dies in the queue.The gate can say no.a run ledger and health check record every event; silence is treated as a bug
The gate has two exits, and one of them is no.
Drafting and checking, before anything reaches the queue.
Drafting and checking, before anything reaches the queue.
The gate: a post publishes only after I approve that exact piece.
The gate: a post publishes only after I approve that exact piece.
Published under my name, after approval.
Published under my name, after approval.

The stages

  1. Collects trends and sources on a timer
  2. Scores each one against the topics I actually write about
  3. Writes opening lines first, then full drafts
  4. Makes the images
  5. Puts the finished piece in a queue for me
  6. Publishes through a scheduling tool, but only once I have approved that exact piece

Where the gate sits

An approval queue in Notion. Every post sits there in full view until a person marks it approved, and the publisher will not touch anything else.

What moves between stages

Every step writes to a permanent log. Sources are ranked by how far they can be trusted, with vendor marketing flagged as vendor marketing, and links are opened and checked before a draft is allowed to cite them.

What broke, and how it surfaced

The engine produced nothing for ten days and never said so. The software it runs on does not restart itself after the computer reboots, so the publishing service was down every morning and each run failed in silence. The permanent log is what exposed it. Now a start-up check refuses to let a run begin until everything it depends on is actually running, and a separate health check watches on its own schedule.

Outcomes, with sources

32posts taken all the way through, from first draft to published, since early July 2026Source A count of the post folders in the 2026 archive, 20 Aug 2026, including posts retired at the approval step (08_ARCHIVE/2026)
0posts published without explicit per-post human approvalSource How it's built: the publisher only acts on a post after a person has marked that post approved in Notion
10days of silent failure, caught and traced to their cause by the permanent logSource The system's permanent run log, which recorded each failure. The cause was a Docker Desktop timing conflict, July 2026 (runs.jsonl)

A system collects sources, drafts posts in my voice, checks the links, and schedules the publishing. Every post then waits in an approval queue until I read that exact piece and decide on it; nothing has ever published any other way.

Read the full story · about 2 minutes

The use case

As a consultant building a public voice, I want the research, drafting, scheduling, and publishing machinery automated, so that my only job is the judgment call: does this post go out under my name?

The problem

A consistent professional presence on LinkedIn is an operations problem disguised as a writing problem. The work that kills consistency is not the writing; it is the harvesting of source material, the checking of claims, the visuals, the scheduling, the follow-through at 6:00am. Fully automated ghost-posting tools solve that by removing the author, which is the one part that cannot be removed. The failure mode I designed against is not a bad draft. It is an unreviewed publish.

How it works

The engine is a numbered-stage pipeline that runs on a schedule: harvest trends and sources, score them against a topic matrix, generate hooks, draft posts, produce visuals, and stage everything into a gate. Source discipline is enforced at harvest: sources are tiered, vendor content is flagged as vendor content, and links are checked live before a draft cites them. Staged drafts land in a Notion approval queue where each post waits, visible in full, until a human rules on it. Approval triggers publishing through a scheduling tool to LinkedIn. Every event in the pipeline writes to a run ledger, and a separate health check watches the watchers. The whole system runs unattended on scheduled jobs; the only manual step is the one that should be manual.

Where the human sits

One queue, one decision per post. The gate is not a rubber stamp at the end of a conveyor; it can and does say no, and a rejected post dies in the queue without ceremony. Approval means something specific: I read this exact post and I am willing to be its author. The machine earns back hours of production work every week, and in exchange it gets no authority over what is said in my name.

Demo

A short screen recording of the approval flow is planned: the queue as it looks on a real morning, a post being reviewed, and the approve action that releases it. The queue displays unpublished drafts, so the recording ships only after a redaction pass.

Outcomes

Live in production since July 2026. Thirty-two posts have been through the complete cycle, every one of them individually approved by a human before publishing, and none published any other way. The steady cadence is the outcome that matters: the pipeline holds the publishing rhythm whether or not I had a productive writing week.

What broke in production

Three real incidents, all fixed, all instructive.

First, the engine produced nothing for ten days and said nothing about it. Docker Desktop does not start itself after a reboot, so the publishing service was down every morning at run time, and each run failed quietly. The run ledger is what exposed it: a string of failure records nobody had asked to see. The fix was a readiness script that blocks the run until its dependencies are actually up, plus a health check with its own schedule. Status: fixed.

Second, image posts silently stalled in the publisher’s queue while text posts sailed through, which is the worst kind of bug: partial success that looks like success. Root cause was the publishing service failing to fetch images through its own proxy configuration. Fixed at the infrastructure layer, and the orchestrator now verifies the worker actually picked the job up. Status: fixed.

Third, a future-dated post that got re-staged on its publish date created a duplicate row in the approval queue, meaning the same post could be ruled on twice. The fix is a guard that checks for an existing row inside a lock before creating one, and it fails closed: if the guard cannot verify, staging stops rather than risking a duplicate. Status: fixed, shipped, and visible in the production telemetry of this morning’s run.

The pattern across all three is the honest lesson of running agents in production: the default failure mode of automation is silence. Ledgers, health checks, and fail-closed guards are what keep the human a supervisor instead of a bystander.