Building a Content Pipeline on an AI Powered Automation Platform

The Problem: Manual Research is a Soul-Crushing Bottleneck

Last month I had to generate briefs for twelve pillar pages. That meant spending two full days manually opening dozens of competitor pages, copying headlines into a spreadsheet, identifying common themes, and then trying to synthesize a unique angle. It’s necessary work, but it’s also a complete drag and a terrible use of an operator’s time. This article shows you how to build a system on an ai powered automation platform that does 80% of that work for you. After reading this, you’ll have the complete operator playbook for creating an agent that scrapes source URLs, analyzes the content, and drafts a high-quality outline for you to refine.

The Stack: Three Tools to Build Your Research Agent

You don’t need a complex custom-coded solution for this. You just need to connect three specific services. This is the exact stack I use for this workflow.

• The Orchestrator: Make (formerly Integromat). This is the central brain of our operation. It’s a no-code platform that connects APIs and services together with visual workflows. It’s more powerful and, honestly, more intuitive than Zapier automations for multi-step processes. The free plan is a joke for any real work, but their Core plan at $29/month is a fair price for the amount of automation it handles. This is our ai powered automation platform.
• The Scraper: ScraperAPI. You can’t just ask your automation platform to fetch a webpage. You’ll get blocked by firewalls or CAPTCHAs almost immediately. A dedicated scraping service handles all of that for you—proxies, retries, javascript rendering. ScraperAPI is my go-to. It’s reliable and the API is dead simple. You send it a URL, it sends you back the raw HTML. Done.
• The Brain: OpenAI API. This is where the magic happens. We’ll use GPT-4 Turbo to parse the messy HTML, extract the core content, analyze it for themes, and generate our new outline. The cost per run for a workflow like this is pennies. It’s shockingly cheap for the value it provides.

That’s it. A workflow tool, a scraper, and an LLM API. That’s the entire foundation.

The Step-by-Step Workflow Logic

Inside Make.com, you’ll build a ‘Scenario’ that follows this sequence. Each number is a ‘module’ you drag onto the canvas.

1. Trigger: New Row in Google Sheets. Create a simple spreadsheet with one column: ‘SourceURL’. When you paste a URL into a new row, the entire automation kicks off.
2. HTTP Request to ScraperAPI. This module takes the URL from the Google Sheet and sends it to ScraperAPI. The API key goes in the header for authentication. ScraperAPI returns the full, raw HTML of the page.
3. First OpenAI Call: ‘Clean and Extract’. This is a critical step. You don’t want to feed an entire HTML page into GPT-4; it’s inefficient and full of junk like navigation, ads, and footers. Your prompt here is specific: "Given the following HTML, extract only the main article content. Remove all scripts, navigation links, sidebars, and footers. Return only the clean text of the article." This gives you a clean corpus to work with.
4. Second OpenAI Call: ‘Analyze Themes’. Now you take the clean text from the previous step and ask the AI to act as a research analyst. The prompt looks something like: "Analyze the following article text. Identify the top 3-5 core themes, the primary argument, and the intended audience. Output your findings as a JSON object with the keys: 'themes', 'mainArgument', 'audience'." Forcing JSON output makes the next step reliable.
5. Aggregate and Synthesize. If you’re running this for multiple URLs, you’ll collect the JSON outputs from each run. Make.com has tools for aggregating text.
6. Third OpenAI Call: ‘Draft New Outline’. This is the payoff. You feed the aggregated analyses into a final prompt. "You are a content strategist creating a comprehensive and unique article outline. You have been given analysis from several competitor articles. Your task is to create a new outline that covers the topic exhaustively but introduces a novel perspective. Do not copy section headers directly from the source analysis. The outline should include an H1, and a series of H2s with 3-5 bullet points under each one detailing the key points to cover. Here is the analysis: [Insert aggregated JSON here]."
7. Final Step: Output to Notion AI/Google Docs. The final module takes the generated outline and creates a new page in Notion or a new Google Doc, ready for a human writer to start working.

What Most No-Code AI Guides Get Wrong

Almost every tutorial you find online will show you the ‘happy path’ where everything works perfectly. That is not reality. Production systems break in stupid and unpredictable ways. Most guides completely ignore error handling, which is the difference between a fun experiment and a reliable business tool.

Here’s what actually happens: a target site’s structure changes, and your scraper pulls garbage. Or an API call times out. Or the LLM, for no good reason, returns a malformed JSON object that breaks the next step in your chain. In most basic setups, this kills the entire workflow. The whole thing just stops, often silently.

You have to build for failure. In Make.com, this means using a ‘Router’ module after any step that can fail (like an API call). The router creates branches. Path A is the ‘happy path’—the data looks good, so proceed to the next step. Path B is the error path. If the ScraperAPI call fails, for example, the error path could send you a Slack notification with the failed URL and the error message. It doesn’t fix the problem, but it tells you *what* broke *when* it broke, so you’re not guessing. This is a fundamental concept in any real automation, and its absence from most no-code tutorials is a huge disservice.

How Do You Keep the AI Output From Sounding Robotic?

This is the most common question, and it comes down to one thing: prompt quality. Garbage in, garbage out. A lazy, one-sentence prompt will give you a generic, soulless outline. A detailed, constrained prompt will give you something 90% of the way to a finished product.

My concrete love for the current generation of models, especially GPT-4, is their ability to adhere to complex instructions and personas. Use that.

Don’t just say “Write an outline.” Give the AI a job title, a context, and a very specific format to follow. Here’s a piece of a prompt I actually use:

"You are an expert content strategist with 15 years of experience writing for a skeptical, technical audience. You are creating a detailed blueprint for a writer. Your tone should be authoritative but clear. The output MUST be a markdown-formatted article outline. The outline must contain exactly one H1 title. It must contain between 5 and 7 H2s. Each H2 must have a list of 3 to 5 bullet points beneath it, with each bullet point being a complete sentence that explains the concept to be covered in that section. DO NOT include a conclusion section."

See the difference? We’ve given it a role, a target audience, a tone, a precise structure, and a negative constraint (‘DO NOT include a conclusion’). This level of detail is how you guide the model to produce high-quality, non-generic work. It’s the core skill of building any valuable ai automation blueprint.

Debugging 101: Finding the Broken Link in the Chain

Your automation will break. Not if, but when. Your first instinct will be to stare at the whole workflow and feel overwhelmed. Don’t. The key is to isolate each step.

In Make.com, after a scenario runs, you can click on each module to inspect the data that flowed into it (the input) and the data that came out of it (the output). This is your first stop. Start at the beginning. Did the Google Sheet module pull the correct URL? Yes. Okay, move to the next one. Did the ScraperAPI module output HTML, or did it output an error? Ah, it output an error. Now you know the problem is in that specific step. You can check the error details to see if it was a timeout, a 404 not found, or a block.

Here’s my big gripe with Make.com, though. While you can see the data, the interface for viewing complex data like a big JSON object or a huge block of HTML is clunky. It’s a tiny, non-resizable pop-up window. It’s infuriating when you’re trying to find a specific broken piece of data. My workaround is crude but effective: add a temporary Google Sheets ‘Update a Row’ module after a problematic step and dump the raw output into a cell. Seeing the data laid out in a spreadsheet is often much easier than trying to parse it in that tiny inspection bubble. It’s an extra step, but it saves so much frustration.

This is the simple truth of being an operator. You spend more time debugging than you do building.

We cover this in more depth elsewhere — deeper coverage of AI agent platforms.

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