AI workflow for content creation

You spend hours moving drafts between ChatGPT, Notion, and Google Docs, then rewriting the same prompts for each new piece. By the end of this guide you’ll have a repeatable system that pulls a brief, runs it through a set of AI agents, and drops a polished draft into your CMS—all with a single click.

What most guides get wrong about AI content pipelines

Most tutorials treat AI like a magic button: feed it a topic and expect a finished article. They ignore the fact that language models need structure, context, and quality gates. Without those, you get generic output that still requires heavy editing.

What they also skip is the cost of context switching. Jumping from a chat UI to a document editor to a CMS kills momentum. A real workflow keeps the creator inside one environment, letting the AI do the heavy lifting while you stay focused on direction.

Finally, many guides pretend the tools work out of the box. In reality you need to tune prompts, set token limits, and handle errors. Ignoring those details leads to frustration when the pipeline stops mid‑run.

Pick your tools: a concrete named example

Here’s the stack I run for my freelance blog business: Notion as the hub, the Make platform for automation, OpenAI GPT‑4o for writing, and WordPress via its REST API for publishing. All of them have free tiers that let you test the flow before committing.

First, I create a Notion database called “Content Briefs” with fields for title, target keyword, tone, and outline. Each row is a potential article. When I change the status to “Ready”, a Make scenario triggers.

The scenario does three things: it pulls the brief, builds a prompt for GPT‑4o, and sends the request. The prompt looks like this:

Write a 1200‑word article titled “{{title}}”. Target keyword: “{{keyword}}”. Tone: {{tone}}. Use the following outline:
{{outline}}
Include a short intro, three body sections with subheadings, and a conclusion. End with a call‑to‑action that invites readers to comment.

I store that prompt in a Make text aggregator so I can tweak it without opening the scenario editor. The AI returns markdown, which Make then posts to WordPress using the wp/v2/posts endpoint. The whole run takes about 90 seconds.

Cost breakdown: Notion Personal Pro $8/mo, Make free tier covers up to 1 000 operations/mo (more than enough for 20 articles), OpenAI API $0.03 per 1 000 tokens (roughly $0.45 per article at 15 k tokens), WordPress hosting $5/mo on a shared VPS. That puts the per‑article cost under $1, far below any subscription Writer.com.

How to debug when this breaks

When the pipeline fails, the first place to look is the Make scenario log. It shows each module’s status and any error messages. Common failure points are:

• Authentication token expired for WordPress – regenerate the app password and update the Make connection.
• OpenAI rate limit – you’ll see a 429 response. Add a pause module before the AI call or upgrade to a higher tier.
• Missing fields in the Notion brief – if the outline is empty the prompt becomes nonsensical. Add a filter that stops the scenario when outline is empty and sends you an email alert.
• Markdown formatting issues – WordPress expects HTML. I use a Make text transformer that runs the markdown through a lightweight converter (I use the open‑source marked library via a custom webhook). If the converter throws, the scenario logs the raw output so you can fix the prompt.

If the log looks fine but the article never appears, check the WordPress response body. A 201 means success; any 4xx or 5xx points to a permission or data problem. I keep a simple Google Sheet that logs the post ID, timestamp, and status for every run – it’s saved me hours of guesswork.

Why does the workflow stall at scale?

You might wonder what happens when you try to run 50 briefs at once. The answer is that the free Make tier starts throttling after about 30 operations per minute, causing some scenarios to queue and then timeout. The symptom is a bunch of “Scenario stopped because it exceeded the execution time” errors.

To fix that, either upgrade to Make’s Core plan ($9/mo) which raises the limit to 1 000 operations/min, or batch the triggers: schedule the scenario to run every five minutes and process only ten briefs per run. I use the latter because it keeps costs flat and still gives me a steady flow of content.

Another scaling issue is the OpenAI token budget. At 15 k tokens per article, 50 articles consume 750 k tokens, which at $0.03 per 1 k is $22.50 – still cheap, but you need to monitor usage to avoid surprise bills. I set a daily usage alert in the OpenAI dashboard at $30.

Price check and opinion on the stack

Let’s talk numbers. The total monthly outlay for the stack described above is roughly $27: Notion $8, Make Core $9, WordPress hosting $5, OpenAI usage $5 (based on 150 articles). That’s $0.18 per piece if you hit 150 articles a month.

I think paying $199/mo for an “all‑in‑one” AI writer is ridiculous for what you get – you’re mostly paying for a polished UI that hides the same API calls you can make yourself for a fraction of the cost. The free tier of Make is enough for solo work; the $9 Core plan only becomes necessary when you start hitting real volume.

On the love side, I adore how Notion’s database views let me see every article’s status at a glance – a simple kanban board moves items from “Idea” to “In Progress” to “Published” with a drag. That visual feedback keeps me honest about my pipeline’s health.

As a gripe, the biggest annoyance I’ve hit is the undocumented rate limit on Make’s free webhook module. After 20 incoming webhooks per minute it silently drops the rest, leaving you wondering why half your briefs never triggered. The fix is to add a pause module before the webhook or upgrade – something the docs never mention.

(Which, yes, is annoying, but it’s a one‑time tweak that saves you from missed deadlines.)

Adjacent reading: deeper coverage of AI agent platforms.

Putting it all together: a numbered step list

1. Create a Notion database with fields: Title (text), Keyword (text), Tone (select: Formal, Casual, Persuasive), Outline (multi‑line text), Status (select: Idea, Ready, In Progress, Published).
2. In Make, start a new scenario with a Notion “Watch Database Items” module set to trigger when Status changes to Ready.
3. Add a Notion “Get Database Item” module to pull the full row.
4. Use a Text Aggregator to build the prompt: combine the static instruction template with the four fields from Notion.
5. Add an HTTP “Make a request” module to OpenAI’s chat completions endpoint (POST https://api.openai.com/v1/chat/completions). Set the Authorization header to Bearer your‑API‑key. Body includes model “gpt-4o”, messages array with a system role “You are a helpful writer” and a user role containing the aggregated prompt, temperature 0.7, max tokens 2000.
6. Add a Parser module to extract the assistant’s message content from the OpenAI response.
7. Add a Text Transformer module that runs the markdown through a markdown‑to‑HTML converter (you can call a small webhook that uses the marked library).
8. Add an HTTP “Make a request” module to your WordPress site (POST https://your‑site.com/wp-json/wp/v2/posts). Set Authentication to Username/Password using an Application Password. Body includes “title” (from Notion), “content” (the HTML from previous step), “status” “publish”.
9. Finally, add a Notion “Update Database Item” module to set the Status to Published and store the WordPress post ID in a new field for tracking.
10. Save the scenario, turn it on, and test with a single brief. Check the WordPress post, then move on to batch runs.

If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this workflow as a blueprint at deepusecase.com/vault.