Make Automation: Publish Once, Distribute Everywhere

What This Builds

A Make (formerly Integromat) automation that watches for new blog posts published to your WordPress or Webflow site, automatically sends the full content to OpenAI's API to generate a platform-specific social media content pack (LinkedIn post, 3 tweets, email newsletter summary, Instagram caption), and saves the drafts to Buffer for your review. Instead of spending 60–90 minutes repurposing every article, you spend 5 minutes reviewing drafts that are already waiting for you.

Prerequisites

• Make account (free tier works for testing; Core plan $9/month for production)
• WordPress or Webflow website with a blog
• OpenAI API account with billing enabled ($5–10/month for typical usage)
• Buffer account for social scheduling (free tier works; Essentials $6/month)
• Comfortable with basic "if this, then that" logic (no coding required)

The Concept

Make is like building with LEGO — you connect blocks (called "modules") that each do one thing: watch for something to happen, process information, send information somewhere else. Your automation has 4 blocks:

1. Watch — checks for new WordPress posts every 15 minutes
2. Extract — gets the full text of the new post
3. Generate — sends the text to OpenAI API with a prompt, gets back social content
4. Save — adds each social format as a draft in Buffer

Think of it as hiring an assistant who works 24/7, reads every article you publish, and has drafts waiting in your social scheduler before you finish your morning coffee.

Build It Step by Step

Part 1: Set Up Make and Connect Your Services

Step 1: Create a Make account at make.com → log in → click "Create a new scenario"

Step 2: Add the first module — the trigger. Click the large "+" in the center → search "WordPress" → select "Watch Posts"

• Connect your WordPress site (you'll need your WordPress URL, username, and Application Password)
• To create an Application Password: In WordPress Admin → Users → Your Profile → scroll to "Application Passwords" → create one → copy the password
• In Make: enter your WordPress URL + username + Application Password → Test → confirm it connects

Step 3: Add the OpenAI module. Click the "+" after WordPress → search "OpenAI" → select "Create a Completion"

• Connect your OpenAI API key (get from platform.openai.com → API Keys → Create)
• Model: select gpt-4o (best quality) or gpt-4o-mini (faster/cheaper)

Step 4: Add the Buffer module. Click "+" after OpenAI → search "Buffer" → select "Create a Post"

• Connect your Buffer account (OAuth — you'll be redirected to approve)

Part 2: Configure the Content Generation

The prompt you send to OpenAI is the most important configuration. In the OpenAI module, set up the Message field:

System message (sets up the AI's role):

You are a social media content writer for [Brand Name]. Brand voice: [3 adjectives — e.g., "direct, practical, no-jargon"].
Target audience: [1 sentence description].
Never use: [banned words list].

User message (the actual request — use Make's dynamic variables to insert the blog content):

In the Message field, click inside it → use Make's variable picker to insert:

• {{1.title}} = WordPress post title
• {{1.content}} = WordPress post body

Then write your prompt around those variables:

Here is a blog post we just published:

Title: {{1.title}}

Content: {{1.content}}

Generate a social media content pack with these exact sections, in this exact format:

LINKEDIN:
[200-word LinkedIn post with line breaks for readability. Hook sentence first. End with a question to drive engagement.]

TWITTER_1:
[Tweet under 280 chars — the most surprising stat or insight]

TWITTER_2:
[Tweet under 280 chars — a practical takeaway]

TWITTER_3:
[Tweet under 280 chars — a contrarian angle or question]

EMAIL:
[100-word newsletter summary, 2 paragraphs. First: what the article covers. Second: one key takeaway and link to read more.]

INSTAGRAM:
[Instagram caption under 150 words + 5 relevant hashtags]

Why this format matters: Writing the exact section headers (LINKEDIN:, TWITTER_1:, etc.) makes it easy to parse the output in Make's next step and send each format to the right Buffer queue.

Part 3: Parse and Route to Buffer

After the OpenAI module runs, Make has a text response with all 5 sections. Now you need to extract each section and send it to Buffer.

Step 1: Add a Text Parser module. Click "+" → search "Text Parser" → "Match Pattern"

For LinkedIn, use the pattern: LINKEDIN:\n([\s\S]*?)(?=TWITTER_1:|$)

This extracts everything between "LINKEDIN:" and "TWITTER_1:" — the LinkedIn post text.

Repeat for each format: TWITTER_1, TWITTER_2, TWITTER_3, EMAIL, INSTAGRAM.

Step 2: For each Buffer module, connect it to the corresponding text parser output:

• Buffer Channel: select your LinkedIn page / Twitter / Instagram
• Content field: {{result of text parser}} (the extracted text for that format)
• Status: "draft" — so you review before publishing

Part 4: Test and Refine

Step 1: Click "Run once" in Make with a recent post. Watch each module run — green checkmarks mean success, red means an error.

Common errors and fixes:

• WordPress connection fails: Check your Application Password — generate a new one in WordPress and re-enter
• OpenAI "context too long" error: Your article is too long for the model. Add a Text Parser module before OpenAI that trims the content to 3,000 words: use "Limit Text Length" pattern
• Buffer module fails: Check that your Buffer account has the right profiles connected and that you selected the correct channel in the Buffer module

Step 2: Check Buffer's draft queue — you should see 5 draft posts waiting (LinkedIn, 3 tweets, 1 Instagram). Read each one. How close is it to your client's voice?

Step 3: Refine the prompt. The first run will likely need adjustments. Common improvements:

• If LinkedIn posts are too long: "LINKEDIN: Under 150 words."
• If tweets are too generic: "Each tweet must include a specific number, statistic, or direct quote from the article."
• If the voice is wrong: Strengthen the brand voice instructions in the System message.

Real Example: Content Distribution for a B2B Blog

Setup: Marketing agency publishes 2 blog posts/week for client TechFlow. Currently takes 90 minutes per post to create social content.

Workflow:

1. Article publishes on TechFlow WordPress
2. Make triggers within 15 minutes
3. OpenAI generates social pack (voice: "direct, practical, collegial")
4. Buffer drafts waiting: 1 LinkedIn, 3 tweets, 1 email summary, 1 Instagram caption

Input (WordPress post): "5 Reasons Manual Onboarding Is Costing You More Than You Think" — 1,400-word article with statistics on onboarding costs

Output (LinkedIn draft from Make): "Manual onboarding costs more than most HR teams realize — and not just in time.

A new hire going through a paper-and-email checklist process costs the average mid-size company $1,200 more per person than an automated workflow. Multiplied across 50+ hires per year, that's $60,000+ in hidden costs that never appear on a single line item.

The four places it bleeds: duplicated admin work, delayed system access (avg 2.7 days), missed training steps, and compliance gaps that surface in audits.

We broke down exactly where the money goes — and what a realistic fix looks like.

[Link in comments]

What's the most painful part of onboarding in your organization?"

Time saved: 80 minutes repurposed; 5 minutes reviewing and approving drafts.

What to Do When It Breaks

Make scenario stops triggering → Check the Make scenario is "Active" (green toggle). Also check that you haven't hit your Make operations limit for the month.

OpenAI output is too long and gets cut off → Add "Keep each section under X words" to the prompt. Or increase Make's text length limits in the OpenAI module settings.

Buffer posts are published (not just drafted) by accident → In the Buffer module, check "Create as draft" is selected, not "Share Now." Re-check Buffer for any published posts.

The voice is completely wrong → Add 2–3 paragraph examples of ideal output directly into the System message: "Here's an example of what the LinkedIn post should sound like: [example]."

Variations

Simpler version: Skip Make entirely — just run the prompt manually in ChatGPT after each post publishes. Takes 3 minutes, no setup required. Good way to test the prompt before automating.

Extended version: Add a Slack notification module after Buffer so you (or the client) get a Slack message with all 5 draft links for review. Makes the approval loop faster.

What to Do Next

• This week: Build the scenario and test it with 2 existing articles to calibrate the prompt quality
• This month: Let it run live for 4 weeks and track: total time saved vs. manual repurposing, and whether AI-drafted social content performs differently from manually written posts
• Advanced: Add a second OpenAI step that scores the content ("Rate this LinkedIn post for engagement potential 1-10 and explain why") before sending to Buffer — auto-filter weak drafts

Advanced guide for copywriter professionals. These techniques use more sophisticated AI features that may require paid subscriptions.