The content production pipeline

Three clients each expect four articles a month, and by week two the writer is asking what an article is actually for, the editor is rewriting strategy in the margins, and something goes live with the wrong city in the opening line. Nobody involved is bad at their job. The agency is missing a pipeline: fixed stages, a named owner for each, and a defined artifact that passes from one stage to the next.

Five stages, and what passes between them

Every article moves through the same five stages: brief, draft, review, publish, verify. The stages themselves are obvious. What turns them into a pipeline is that each stage produces one artifact the next stage consumes, and each artifact has a standard someone can check.

1. The brief turns strategy into instructions. Owned by whoever runs the client's strategy. The artifact is one page saying what to write, for whom, and why.
2. The draft turns the brief into words. Owned by a writer or a generator. The artifact is a complete draft with its internal links and images in place.
3. Review turns the draft into something a client can see. Owned by an editor who didn't write it. The artifact is a pass on a fixed checklist.
4. Publish turns the approved file into a page on the client's site. Owned by whoever holds CMS access. The artifact is a public URL.
5. Verify confirms that URL actually loads. Same owner as publish. The artifact is the page, fetched and found.

When quality drops as volume rises, look at the handoffs before you look at the people. The failure is almost always an artifact that was never defined: the writer got a keyword instead of a brief, so the editor did strategy during review, so review ran out of time for the checks it was supposed to run.

The brief is the stage agencies skip

An article can only be as good as the question it was asked to answer, and the brief is where the question gets asked. A usable brief fits on a page: the target keyword and the intent behind it, the page type that intent calls for, who the reader is, the questions the article must answer, what the current top results miss, the internal links to include, and anything the client has to approve, such as claims about their own prices or guarantees.

Skipping the brief doesn't remove that work. It moves it downstream to the most expensive stage: an editor who discovers mid-review that the article targets the wrong intent has to send it back through drafting, and now the article has cost two passes instead of one.

The questions section writes itself from the search results. The queries Google surfaces under a result are the questions real searchers asked, so pull them and put them in the brief rather than guessing.

Drafts are raw material, wherever they come from

Whether a human or an AI wrote it, the same rule applies: the draft is input for review, never the deliverable. That framing removes most of the argument about AI content. A generator's draft and a freelancer's draft go through the same gates, and whichever fails gets fixed.

Drafting tools come in two shapes. One-pass generation produces a draft quickly and cheaply, which suits volume topics where good enough is fine. Score-gated pipelines research the current top results, draft, score the draft against fixed checks and revise until it clears a bar, which suits pages that have to compete. The second exists because first drafts, human or machine, usually miss something measurable: length, internal links, a question left unanswered.

At scale, drafting runs off the calendar, not off memory. Plan the month per client, then let each planned item feed the drafting queue on its date, so drafts arrive on schedule and review gets a steady flow instead of a month-end pile. And when drafting gets faster, review becomes the bottleneck. The fix is tighter briefs and binary checks, never skipping review.

Approval, publish and verify are separate acts

The client approves between review and publish, and only there. A client shown raw drafts becomes an unpaid editor and a bottleneck; a client shown checked, finished work approves quickly and learns to trust the pipeline.

Publishing belongs to whoever holds the CMS credentials, as a deliberate act rather than a side effect. And the pipeline ends when the public URL returns the page, not when the CMS says saved. A CMS can record a successful write while the page 404s for a reader, because the post is still a draft on the platform or the template that renders it was never published. Whoever publishes owns checking the page is reachable, so nobody reports a page as live that no reader can open. Publishing to a client's CMS covers that stage in full.

What to take away

• A pipeline is stages plus owners plus defined artifacts, and quality failures at volume are almost always handoff failures.
• The brief is the cheapest stage to fix and the one that moves work out of the most expensive stage, review.
• A draft is raw material for review whoever produced it, which is why AI and human drafts pass the same gates.
• Publishing ends when the public URL returns the page, not when the CMS accepts the write.

Next

The review stage deserves its own checklist. Quality gates before publishing sets out the checks every article passes before a client sees it.