Automation 7 min read ·

Building a Content Pipeline with Make and WordPress

We earn commissions when you shop through the links below.

Building a content pipeline with Make and WordPress is one of the highest-leverage automations you can set up as a developer or content-focused team. Instead of manually copying drafts from Notion, triggering SEO checks, resizing images, and clicking publish — you build it once and let it run. In this guide I’ll walk through exactly how I structured a real pipeline that goes from a Google Doc draft to a published WordPress post, with metadata, featured images, and Slack notifications included.

Why Make for WordPress Automation?

Make (formerly Integromat) is my go-to for this kind of work because it has a native WordPress module that supports creating, updating, and fetching posts without touching the REST API manually. It also handles branching logic, error handling, and data transformation in a visual interface that’s actually readable after you leave it for six months.

Compared to Zapier, Make gives you far more control over the data flow — you can iterate over arrays, parse JSON, use built-in functions for string manipulation, and chain HTTP requests. For a multi-step content pipeline, that flexibility matters.

Pipeline Architecture Overview

Here’s the high-level flow I use:

  1. A Google Doc is moved to a specific folder (trigger)
  2. Make reads the document content and metadata from a paired Google Sheet
  3. An AI module rewrites or summarizes the content (optional)
  4. An image is fetched or generated and uploaded to WordPress media library
  5. The post is created as a draft in WordPress with all fields populated
  6. A Slack message is sent to the editorial channel for review

You can collapse or expand any of these steps based on your needs. The core is steps 1, 2, 4, and 5.

Setting Up the WordPress Connection

Before building anything in Make, you need an Application Password on your WordPress site. Go to Users → Profile → Application Passwords, generate one, and store it somewhere safe. Make will use this with Basic Auth.

In Make, when you add a WordPress module, it will ask for your site URL, username, and the application password. Once connected, you’ll see your custom post types, taxonomies, and all the fields you’d expect.

If you’re hosting WordPress yourself and need a reliable server, Hostinger has solid managed WordPress plans that come with SSL, caching, and enough resources for a content-heavy site without a large monthly bill.

Building the Scenario Step by Step

Step 1: Google Drive Trigger

Use the Google Drive → Watch Files in a Folder module. Set it to trigger when a file is created or modified in your “Ready to Publish” folder. Make polls this on whatever schedule you set — I use every 15 minutes for a near-real-time feel without hammering the API.

Step 2: Read Metadata from Google Sheets

I keep a companion spreadsheet with columns for: doc ID, post title, category, tags, SEO description, featured image URL, and author. The Google Sheets module searches for a row matching the file ID from step 1. This separation of content (Doc) and metadata (Sheet) keeps things clean and easy to update.

Step 3: Fetch and Upload the Featured Image

Use an HTTP → Make a Request module to download the image from a URL in your spreadsheet. Then pipe that binary data into the WordPress → Upload a Media File module. Capture the returned media ID — you’ll need it when creating the post.

Step 4: Parse the Google Doc Content

The Google Docs module returns content as a structured JSON object, not raw HTML. You have two options: use Make’s built-in text extraction, or hit the Google Docs export URL directly to get clean HTML.

I use an HTTP request to export the Doc as HTML:

GET https://docs.google.com/document/d/{DOC_ID}/export?format=html
Authorization: Bearer {GOOGLE_OAUTH_TOKEN}

This gives you actual HTML that WordPress can render without any transformation. The downside is you may get Google’s inline styles — I run the output through a simple Tools → Replace module or a regex to strip those out.

Step 5: Create the WordPress Post

Now use the WordPress → Create a Post module. Map the fields:

Title       → {{sheets.title}}
Content     → {{cleanedHTML}}
Status      → draft
Categories  → {{sheets.category_id}}
Tags        → {{sheets.tags}}
Featured    → {{mediaUpload.id}}
Slug        → {{sheets.slug}}
Excerpt     → {{sheets.seo_description}}

I always create posts as draft first so a human can review before publishing. If you want fully automated publishing, change that to publish — but for most editorial teams, draft + Slack notification is the right balance.

Step 6: Slack Notification

Add a Slack → Create a Message module pointing to your editorial channel. Include the post title, WordPress admin edit link, and the author name pulled from your spreadsheet. Your team gets a notification the moment a new draft lands, without checking dashboards.

Error Handling You Shouldn’t Skip

Building a content pipeline with Make and WordPress that runs unattended means errors will happen — a broken image URL, a Doc that got moved before processing, a WordPress timeout. Set up error handlers on the critical modules:

  • Right-click any module in Make and choose Add error handler
  • Use a Resume handler for non-critical steps like image upload (fall back to no featured image)
  • Use a Rollback or Break for the post creation step so you don’t create malformed posts
  • Add a final Slack message in the error path so your team knows something failed

Extending the Pipeline

Once the core flow works, here’s what I’ve layered on top:

AI rewriting: Drop an OpenAI or Claude HTTP module between content parsing and post creation. Send the raw doc content, get back a polished version. I use this for social media excerpt generation rather than rewriting the full post.

SEO meta population: If you use Yoast or RankMath, their meta fields are accessible via custom fields in the WordPress module. Map _yoast_wpseo_metadesc to your SEO description column.

Multi-site publishing: Need to publish the same content to multiple WordPress installs? Duplicate the WordPress modules with different connections. Make handles this cleanly since each connection is independently authenticated.

Scheduled publishing: Instead of setting status to publish immediately, use the WordPress date field combined with status future. Pull the publish date from your spreadsheet and WordPress handles the scheduling natively.

Real Numbers

The team I built this for was spending roughly 45 minutes per post on manual steps: copying content, uploading images, setting categories, writing excerpts, notifying teammates. With the pipeline running, that dropped to under 5 minutes of review in WordPress before hitting publish. At 20 posts per month, that’s around 13 hours saved — every month.

Building a content pipeline with Make and WordPress doesn’t require any backend code, no custom plugins, and no server maintenance beyond keeping WordPress updated. The entire scenario in Make is around 12 modules once you include error paths, and it took about a day to build and test properly.

Final Thoughts

If you’re managing any kind of content operation on WordPress and still doing the publishing steps manually, this is the automation to build first. The ROI is immediate and the setup is more approachable than it looks. Start with the minimal version — Drive trigger, Sheets lookup, post creation — and add modules as you identify the next bottleneck.

Make’s free tier supports up to 1,000 operations per month, which covers a low-to-medium volume blog easily. For higher volumes or more complex branching, the Core plan is reasonably priced and worth it the moment you cross that threshold.