I’ve been watching the parade of shiny “content orchestration” platforms with a mix of amusement and dread. Everyone seems thrilled to stitch together three different SaaS tools, each with their own opaque pricing tier and data export limitations, to automate what is essentially a glorified assembly line for blog posts. So, I went the other way. I built a workflow that handles the entire process—brief generation, AI drafting, and structured human review—without a single line of proprietary platform code or a monthly subscription to a “workflow engine.”
The core is a series of scripts and open-source tools that live on our own infrastructure. A simple form captures the initial content request, which populates a structured brief template. That brief is then fed into a locally-hosted LLM via a carefully crafted prompt system, not through a chat interface but through a batch process that enforces style and structural guidelines. The output isn’t just dumped into a Google Doc. It goes into a review queue with a checklist system that flags everything from factual claims that need sourcing to tonal inconsistencies. The “human-edit stage” is not a free-form suggestion box; it’s a series of mandatory validation steps that the editor must explicitly clear before the piece can move to publishing.
The total cost is essentially the compute for the LLM and the hours it took to set up. There’s no vendor to suddenly change their API limits, no surprise charge for adding another user to the review stage, and no concern about who is training their models on our content strategy. The lock-in is to our own process documentation, which we can modify on a Tuesday afternoon if we need to, without filing a support ticket.
I know the immediate objection: this requires technical oversight. But that’s precisely my point. The alternative is outsourcing the operational integrity of your content pipeline to a third party whose incentives are not aligned with your long-term control or cost containment. The “no-code” promise of the popular platforms is a trade-off, and the currency is flexibility, data ownership, and ultimately, a realistic understanding of your total cost of ownership. This setup isn’t for everyone, but it exposes the hidden complexity and long-term commitments that the marketed alternatives so gladly help you ignore.
Just my two cents
Skeptic by default
The local LLM batch processing detail is key. That's where so many DIY setups get tangled in API latency and cost creep. Did you containerize the whole pipeline, or are you managing the LLM service separately? I've found that defining the entire workflow, from form submission to review queue, in a single Docker Compose file makes the environment portable and easier to version control.
Commit early, deploy often, but always rollback-ready.
Batch processing with a local LLM is the right move. The real cost isn't just API fees, it's the unpredictable latency when your pipeline gets stuck waiting on a remote service. How are you handling model updates or prompt versioning? That's where my first setup fell apart.
Ship fast, review slower
That checklist approach for human review is such a smart guardrail. It turns a subjective edit into a repeatable QA step. I'm curious, how did you build the checklist logic? Is it a simple if/then in your script, or did you use a rule engine? I've seen teams get bogged down trying to codify "tone" checks.
Show me the accuracy numbers.