My Full Make.com Blueprint For Automating a Sheets OpenAI Ghost Content Pipeline

Why I stopped hand-assembling content

I got tired of copy pasting my way through content.

Idea in Notion. Outline in Docs. Draft in ChatGPT. Formatting in Ghost. Images in Figma. Every post felt like a manual QA job instead of building something once and letting it run.

So I pushed the whole thing into Make.com.

Now a single row in Google Sheets turns into a drafted or published Ghost post. Titles, meta fields, tags, even a first-pass excerpt. All wired together with OpenAI in the middle.

This is the exact blueprint. Not theory. This is the scenario that runs my real content pipeline.

The high-level architecture

The stack is simple on purpose:

• Google Sheets as the content control panel.
• Make.com to orchestrate everything.
• OpenAI to generate and clean up text.
• Ghost (self-hosted) as the CMS.

One sheet row = one post. Status and flags in that row decide if Make should ignore it, draft it, or publish it.

I keep the Make scenario focused. One job. Turn structured data in Sheets into structured content in Ghost.

The Google Sheet schema

Here is the actual column setup from my sheet. No fluff.

• A: id – internal ID, just an incrementing number.
• B: status – idea, ready, generated, published.
• C: title – human-written title seed.
• D: slug – usually auto-generated in Make if empty.
• E: brief – 2–4 bullet outline or a short paragraph.
• F: target_keywords – comma separated SEO terms.
• G: tone – e.g. direct, informal, first-person.
• H: word_count_goal – rough length like 1200.
• I: tags – comma separated Ghost tags.
• J: generated_html – where I store the body HTML from OpenAI.
• K: meta_title
• L: meta_description
• M: excerpt
• N: publish_flag – draft or publish.
• O: ghost_post_id – for updates.

I do not trust LLMs to guess intent. So I give them a tight brief and flags.

The Make.com scenario: the main flow

I run a single Make scenario that does all of this:

• Polls Google Sheets for new ready rows.
• Generates content and meta fields via OpenAI.
• Writes the generated content back into the sheet.
• Creates or updates a Ghost post.
• Updates status and IDs.

I will walk through every module and what it actually does. No hand waving.

Module 1: Google Sheets “Search Rows”

Trigger: I run this scenario on a schedule. Every 15 minutes works for my pace.

First module is a Google Sheets > Search Rows module.

• Spreadsheet: my Content Pipeline sheet.
• Sheet: Posts.
• Filter: status = ready.
• Limit: I cap at 3 rows per run. I prefer small batches.

This returns an array of rows that are ready to be turned into drafts.

Each row carries all the columns I mentioned earlier.

Module 2: Iterator

I drop an Iterator right after Search Rows.

No magic here. It splits the list of rows into separate bundles so I can process each post independently.

The iterator just takes the array of rows from Sheets and iterates over values[].

Module 3: Data cleanup with Text & Tools

I do some pre-processing before I hit OpenAI.

• Trim whitespace from things like title and slug.
• Normalize commas in tags and target_keywords.
• Generate a fallback slug if the cell is empty.

In practice this is a couple of Tools > Text aggregator / Text parser modules and one Set variable module.

Example: to generate the slug I use a simple Make formula in a Set variable module:

lowercase(
  replace(
    replace(
      replace(
        stripDiacritics(title);
        " "; "-"
      );
      "--"; "-"
    );
    "[^a-z0-9-]"; ""
  )
)

If the slug column in Sheets is already filled, I keep it. Otherwise this kicks in.

Module 4: OpenAI “Create a chat completion” for the article body

Now the fun part.

I use the OpenAI > Create a chat completion module. Currently on gpt-4.1 but I keep this modular so I can swap models.

I feed it a structured prompt that merges sheet data and my own style instructions. Here is the actual system + user content simplified to fit here.

System message (in the module):

You are Richard Lemon, a creative web experience developer.
Write opinionated first-person blog posts.
No em dashes. Short paragraphs (max 2-3 lines).
Direct voice, practical, specific.
Use HTML with <h2>, <p>, <ul>, <li>, <pre>.
Do not add <html> or <body> tags.

User message template:

Write a blog post with the following constraints:

Title: {{title}}
Brief: {{brief}}
Target keywords: {{target_keywords}}
Tone: {{tone}}
Word count target: {{word_count_goal}}

Rules:
- Write in first person as if I actually did the thing.
- Be concrete and technical where useful.
- Use only HTML tags for structure (<h2>, <p>, <ul>, <li>, <pre>, <code>).
- No introduction fluff, start with context or action.
- No conclusion heading.

Return only the HTML body.

The output is pure HTML. I do not want Markdown here because Ghost accepts HTML just fine and I like having precise control.

Module 5: OpenAI for SEO meta + excerpt

I split generation into two calls instead of asking one model response to do everything.

Second OpenAI > Create a chat completion module takes the title, target keywords, and a short summary of the generated HTML and creates meta fields plus an excerpt.

System message:

You create SEO metadata for blog posts.
Always stay under the specified character limits.
Return JSON only.

User message:

Post title: {{title}}
Target keywords: {{target_keywords}}
Body HTML (truncated): {{body_preview}}

Generate:
- meta_title: max 60 chars, must include at least one keyword.
- meta_description: 120-155 chars, natural and specific.
- excerpt: 1-2 sentences, no clickbait.

Return JSON like this:
{
  "meta_title": "...",
  "meta_description": "...",
  "excerpt": "..."
}

I then parse that JSON with a JSON > Parse JSON module.

Could I compress this into one call? Sure. I tried that. The meta fields got worse and harder to constrain. So I split it.

Module 6: Write everything back to Google Sheets

At this point I have:

• Cleaned title and slug.
• Generated HTML body.
• Meta title, description, and excerpt.

Before touching Ghost I push this back into the sheet.

I use Google Sheets > Update a Row with:

• Column J → generated_html from OpenAI.
• Column K → meta_title from JSON.
• Column L → meta_description.
• Column M → excerpt.
• Column D → final slug.
• Column B → set to generated.

Why write back before publishing?

Because I like a manual checkpoint. I can read the generated HTML in Sheets, tweak the brief or title, flip status back to ready if I want a regen.

This effectively makes Sheets my content staging area while Ghost stays clean.

Module 7: Filter on publish_flag

Not every generated post should go live.

I add a filter between the Sheets update and the Ghost modules:

• publish_flag = "draft" OR publish_flag = "publish"

If publish_flag is empty or something else, the scenario stops for that row. It will still update the generated fields, but nothing touches Ghost.

When I want a post to move to Ghost I set publish_flag to draft or publish in the sheet.

Module 8: Router for create vs update in Ghost

I use Ghost both for new posts and edits triggered from Sheets.

So I drop a Router with two branches:

• Branch 1: Create when ghost_post_id is empty.
• Branch 2: Update when ghost_post_id is not empty.

This lets me tweak a title or tags in Sheets, set publish_flag again, and push an update to the existing Ghost post.

Module 9: Ghost “Create a post” (branch 1)

On the create branch I use the Ghost > Create a post module.

Here is how I map things:

• Title → Sheet title.
• Slug → final slug from Module 3.
• HTML → generated_html.
• Excerpt → AI generated excerpt.
• Meta title → meta_title.
• Meta description → meta_description.
• Tags → split tags column on comma, trim each value.

For status I map directly from publish_flag:

• draft → Ghost draft.
• publish → Ghost published.

Ghost returns a post object with an id. I capture that and write it back to the sheet.

Module 10: Google Sheets “Update a Row” with ghost_post_id

Immediately after the create call I drop another Google Sheets > Update a Row module.

It takes the id from Ghost and stores it in column O: ghost_post_id. I also set:

• status = published if publish_flag was publish.
• status = generated if publish_flag was draft.

This keeps my spreadsheet the single source of truth. I can filter ideas, generated drafts, and published content without logging into Ghost.

Module 11: Ghost “Update a post” (branch 2)

On the update branch, I use Ghost > Update a post with the stored ghost_post_id.

I do not blindly overwrite everything. Here is my mapping logic:

• Always update HTML from generated_html.
• Update title and slug only if the sheet values changed.
• Update meta fields if they exist in Sheets. Otherwise keep Ghost values.
• Tags are rebuilt from the tags column every time.

In Make that means I use if expressions in the field mapping. For example:

if(
  empty(sheet_meta_title);
  ghost.meta_title;
  sheet_meta_title
)

I apply a similar pattern for slug and description.

Module 12: Error handling and logging

I do not like silent failures.

So I added a simple error path using Make’s built-in error handlers:

• If Ghost or OpenAI throws an error, I catch it in a separate route.
• Then I write the error message into a errors column in Sheets.
• I also ping myself with a Gmail > Send an email module when something breaks.

Nothing fancy. Enough to see when the pipeline has issues without watching Make all day.

Why I structured it this way

I tried a few alternative versions before landing on this flow.

What I did not like:

• Single gigantic OpenAI prompt that tried to output HTML, meta, title variants, tag suggestions, everything. It was brittle.
• Direct Sheets to Ghost without writing generated content back first. Harder to see what the model produced.
• No publish_flag, so everything went straight to draft in Ghost. That got noisy fast.

What works better for me now:

• Sheets is the control tower. All fields visible. Easy to override.
• Make is the transport layer. No business logic hidden in Ghost.
• OpenAI is a dumb transformer that takes structured inputs and outputs structured HTML and metadata.

The end result is that I spend time on outlines and ideas, not formatting posts or fighting CMS UI.

How this feels in daily use

Here is my actual workflow on a random Tuesday.

• I open the Posts sheet and dump three new ideas as rows with rough titles and briefs.
• I set status = ready and leave publish_flag empty.
• Make picks them up, runs OpenAI, writes back generated HTML and meta, sets status = generated.
• I skim the HTML in Sheets. If a post feels off, I tweak the brief or title, flip status back to ready and let it regenerate.
• Once I like a post, I set publish_flag = draft or publish.
• Next run, Make pushes it into Ghost accordingly.

I still edit inside Ghost sometimes. Especially for code-heavy posts or things where I want to insert images manually.

But 80 percent of the grunt work is automated. Which is the point.

If you want to copy this

If you are already using Make, you can rebuild this in an afternoon.

The three non-negotiables in my experience:

• Use Sheets as a real schema, not a random dumping ground.
• Keep OpenAI prompts tight and specific. One job per call.
• Always round trip data back into Sheets so you can see what the system did.

From there you can layer on extras. Social post generation, image generation, cross-posting to other platforms. I keep those in separate scenarios so this core pipeline stays boring and reliable.

That is the full blueprint I run right now. It will probably change again in a month. But the core idea stays the same. Treat your content as structured data, not as a CMS typing session.