AI Workflow Automation

I think everyone has experienced something like this:

  • Every morning when you get to the office, you spend half an hour checking emails, filtering out the important ones, and then replying to them one by one.

  • After receiving customer feedback, you have to manually organize and categorize it, then send it to the responsible person.

  • Social media needs to be updated regularly, and every time you have to write copy, create images, and schedule posts.

These repetitive tasks consume a lot of your time, but they don't really require much thinking.

AI workflow automation is exactly the solution to this kind of problem: handing over repetitive tasks with clear rules to AI for automatic completion.

The core goal of workflow automation is:Free your time from execution and use it for decision-making。


What is an AI Workflow

An AI workflow connects multiple AI capabilities and tools to form an automated process.

Simply put: when a certain event occurs, it triggers a series of actions, with AI performing understanding, judgment, and generation in between.

The Concept of Workflow Automation

A typical workflow consists of three parts:

ComponentPurposeCommon Examples
TriggerThe condition under which execution startsReceiving a new email, scheduled time, someone submitting a form
ActionWhat operation to performSending a message, saving data, generating content
ConditionHandle different cases differentlyIf it is an urgent email, send a notification; otherwise, organize a summary

Here is a concrete example:

  • Trigger: Check the designated news website every 6 hours.

  • Action 1: AI fetches the news content and filters out items relevant to your industry.

  • Action 2: AI summarizes the relevant news into a summary of no more than 100 characters.

  • Action 3: Send the summary to your Slack channel.

This is a complete AI workflow. Once set up, it runs automatically without any action needed from you.

AI Workflow vs Traditional Automation

The biggest difference between AI workflows and traditional automation is that AI can handle unstructured content and make judgments.

Comparison ItemTraditional AutomationAI Workflow
Content HandlingCan only process structured dataCan understand text, images, and speech
Rule SourceRules must be hardcoded by humansAI can make judgments based on content
FlexibilityRewriting is required whenever rules changeBehavior can be changed by adjusting prompts
Suitable ScenariosSimple, repetitive, deterministic tasksComplex tasks that require understanding and judgment

For example, after receiving an email, forward it to Zhang San — this is traditional automation, with clear rules.

After receiving an email, AI judges its importance; important ones are immediately notified, unimportant ones are summarized and sent weekly — this is an AI workflow, requiring understanding and judgment.


n8n Workflow Platform

n8n is an open-source workflow automation tool that can be self-hosted or used via the cloud version.

n8n's feature is fully visual operation, allowing you to build complex workflows by dragging and dropping.

Open source address:https://github.com/n8n-io/n8n

n8n Installation

Experience n8n with one command via npx (requires Node.js environment pre-installed):

npx n8n

You can also use Docker to deploy and run:

# 创建数据持久化卷
docker volume create n8n_data
# 启动 n8n 容器
docker run -it --rm --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

After deployment is complete, open http://localhost:5678 in your browser to see the n8n interface.

If you don't want to build it yourself, you can also use the n8n Cloud versionhttps://n8n.io/, just register and use it directly.

Core Concepts: Nodes, Connections, Triggers

n8n's interface consists of a canvas and nodes. You can start using it by understanding three core concepts:

ConceptFunctionDescription
NodeExecute specific operationsFor example, "send email", "call OpenAI", "save data"
ConnectionConnect nodes in seriesDrag from one node to another to define the execution order
TriggerStart the workflowThe first node of each workflow, defining "when to start"

Basic steps to create a workflow:

  • 1. Add a trigger node on the canvas (such as "Schedule Trigger" or "Webhook").

  • 2. Add the first action node and configure its parameters.

  • 3. Drag a line from the trigger to connect to the action node.

  • 4. Continue adding more nodes and connect them in sequence.

  • 5. Click "Test" to see if the flow runs normally.

  • 6. Activate the workflow to let it run automatically.

Integrating OpenAI Nodes

n8n has a built-in OpenAI node that can directly call GPT models.

Configuration steps:

  • 1. Find OpenAI in the node list and drag it onto the canvas.

  • 2. Add your OpenAI API Key in the node settings.

  • 3. Select the model to use (such as gpt-3.5-turbo or gpt-4).

  • 4. Write the prompt, which can reference output data from previous nodes.

A typical prompt configuration might look like this:

请把下面的邮件内容总结成 3 句话摘要:

{{$json.body}}

摘要:

Here {{$json.body}} references the body content from the previous email node.

Hands-on: Automatically Summarize Emails and Send Slack Notifications

Let's build a complete workflow: after receiving an email, AI summarizes the content, then sends it to Slack.

This workflow requires three nodes:

  • 1. Email trigger: triggers when a new email is received.

  • 2. OpenAI node: summarizes the email content into a summary.

  • 3. Slack node: sends the summary to a specified channel.

Configuration highlights:

  • Email node: configure IMAP or use n8n's email trigger.

  • OpenAI node: set the prompt to summarize this email in no more than 100 characters, with the input referencing the email body.

  • Slack node: configure the Slack Bot Token, select the channel, and have the message content reference the OpenAI output.

Connect these three nodes, test and activate after passing, and the workflow will run automatically.

n8n's node library is very rich, supporting hundreds of services such as Gmail, Notion, Airtable, Google Sheets, etc. Take time to explore the node library, and you'll find many scenarios that can be automated.


Make (formerly Integromat)

Make is another popular workflow automation platform, formerly named Integromat, renamed to Make in 2021.

Compared to n8n, Make is more geared toward business users, with a more polished interface and more powerful paid features.

Make vs n8n Comparison

Comparison itemn8nMake
Open sourceYes, can be self-hostedNo, pure SaaS
Free versionSelf-hosted completely freeYes, with limited features
InterfaceMore technicalMore user-friendly and polished
Number of nodesHundredsThousands
Enterprise featuresRequires paid versionComprehensive
Learning curveSomewhat steepRelatively gentle

In short: if you want full control and have technical skills, choose n8n; if you want ease of use and enterprise support, choose Make.

Using AI Modules

Make has several built-in AI-related modules:

OpenAI module: calls models like GPT, DALL-E, Whisper.

Make AI module: Make's own AI features for intelligent data processing.

Other AI tools: supports Anthropic Claude, Google AI, Midjourney, etc.

Process for using AI in Make:

  • 1. Search for OpenAI or the AI tool you want in the module library.

  • 2. Drag it onto the scenario canvas.

  • 3. Configure API keys and parameters.

  • 4. Pass data from previous modules to the AI module.

  • 5. Pass the AI's output to subsequent modules.

A distinctive feature of Make is the AI prompt assistant—you can describe what you want in natural language, and it will generate prompts for you.

Practical Examples

Let's build a "social media content auto-generation" workflow with Make:

  • 1. Trigger: scheduled trigger at 9 AM every Monday.

  • 2. Google Sheets module: reads your pre-prepared product updates and activity information.

  • 3. OpenAI module: generates copy for Weibo, LinkedIn, and Twitter based on the spreadsheet content.

  • 4. Airtable module: saves the generated copy to a review table.

  • 5. Slack module: notifies you "This week's content has been generated, please review it in Airtable".

Once the entire flow is set up, it runs automatically every Monday. You only need to review and fine-tune the content, not write copy from scratch.


Zapier AI Automation

Zapier is the pioneer in workflow automation, founded in 2011.

Zapier is characterized by the most connected apps (over 6000) and the simplest usage.

Zapier Basics

Zapier calls workflows Zaps. Steps to create a Zap:

  • 1. Choose the trigger app and trigger event (e.g., "Gmail receives new email").

  • 2. Connect your account and configure trigger conditions.

  • 3. Choose the first action app and action event (e.g., "OpenAI generates text").

  • 4. Configure action parameters, referencing data from the trigger.

  • 5. You can continue adding more actions.

  • 6. Test and enable the Zap.

Zapier's interface is more simplified than n8n and Make; each step is form-based, no dragging or connecting needed.

AI Actions Feature

Zapier introduced a dedicated AI Actions feature that lets you describe what you want in natural language, and it automatically configures the entire Zap.

For example, you input:

当我收到带有"发票"标签的邮件时,把附件保存到 Google Drive,
然后用 AI 提取金额和日期,记录到 Airtable,
最后给我发一条 Slack 通知。

Zapier AI automatically identifies the required steps and configures each node for you.

You can also use AI to help write prompts. For example, when calling GPT, you say "Help me write a prompt to summarize this email", and AI generates a professional prompt template.

Suitable Scenarios

Zapier is best suited for these scenarios:

ScenarioWhy choose Zapier
Connecting niche appsZapier supports 6000+ apps, many that others don't have
Personal simple automationSimplest interface, fastest to learn
Non-technical usersNo technical background needed
Rapid prototype validationBuild a workflow in minutes

Tool selection advice:Beginners start with Zapier, use n8n for deeper control, choose Make for enterprise-level needs.Actually, the core idea of the three tools is the same. Once you learn one, switching to another is easy.


Custom GPT and Claude Projects

Besides using workflow tools to connect multiple services, you can also create dedicated AI assistants to handle specific tasks.

OpenAI's GPTs and Anthropic's Claude Projects are both such tools.

Create Your Own AI Assistant

Taking OpenAI GPTs as an example, the steps to create a custom assistant:

  • 1. Go to the ChatGPT official website, click "Explore" → "Create a GPT".

  • 2. In the "Create" tab, describe the assistant you want in natural language.

  • For example: "You are a example technical documentation editor, responsible for explaining complex technical concepts in an easy-to-understand way, suitable for beginners."

  • 3. In the "Configure" tab, configure more detailed settings.

  • 4. Add knowledge base files (optional).

  • 5. Configure features (such as web search, code interpreter).

  • 6. Test, adjust, and finally publish.

The creation process for Claude Projects is similar; you operate in the Projects feature on the Claude official website.

Knowledge Base Upload

A major advantage of custom AI assistants is the ability to upload your own knowledge base.

Supported file formats typically include:

FormatDescription
PDFMost commonly used, suitable for documents, reports, books
TXTPlain text, simple and universal
DOCXWord documents
CSVTabular data
JSONStructured data

After uploading, the AI will answer questions based on this knowledge.

For example, you can upload the company's product documents, customer service manuals, and historical cases to create an "internal knowledge assistant" that employees can directly ask questions.

Or upload all the articles you have written to create a "writing style assistant" that mimics your style to write new content.

Instruction Customization

Instructions are the core of a custom assistant; they define the AI's role, behavior, and output format.

A good instruction typically includes:

  • Role definition: who you are, what you do.

  • Behavior guidelines: what you should do and what you should not do.

  • Output format: what the structure of the answer looks like.

  • Constraints: what taboos and cautions exist.

Give an example of an instruction:

你是 example 的技术文档助手。

你的任务是把复杂的技术概念解释得通俗易懂,适合初学者。

回答时请遵循这些规则:
1. 先用一句话简单解释是什么
2. 然后用生活中的例子类比
3. 最后给出一个最简单的代码示例
4. 如果有重要的注意事项,用加粗标出

不要使用太深的术语,必要术语要解释。
保持语气友好、鼓励,像老师在教学生。

The more specific the instruction, the more stable the AI's performance.


Webhooks and Triggers

Webhook is a very important concept in workflow automation; it allows external systems to trigger your workflow in real time.

How Webhooks Work

Simply put, a Webhook is a "URL callback address".

The traditional way is "polling": your system asks the external system "Any new data?" at intervals — this is inefficient.

Webhook is "push": when the external system has new data, it proactively sends an HTTP request to notify you.

The Webhook workflow:

  • 1. You create a Webhook trigger in n8n/Make/Zapier and get a URL.

  • 2. Configure this URL in the external system (e.g., GitHub, Stripe, your website).

  • 3. When an event occurs in the external system (e.g., someone commits code, someone makes a payment), it sends data to this URL.

  • 4. Your workflow receives the data and starts executing.

Webhooks are real-time; they can trigger the workflow within milliseconds after an event occurs.

Event-Driven Automation

Webhooks make event-driven automation possible.

Common Webhook event sources:

Event sourceTypical eventsUse case example
GitHubSomeone commits code, someone opens an IssueAutomatically reply with AI when an Issue is received
StripeSomeone makes a payment, subscription expiresSend a thank-you email when a payment is received
TypeformSomeone submits a formAfter form submission, AI analyzes the content and assigns
ShopifyNew orders, inventory alertsAutomatically generate shipping orders for new orders
Your websiteUser registration, messagesWelcome email for new user registration

We'll use Python to implement a simple Webhook receiving + AI processing flow:

Examples

# ============================================
# Simple Webhook server + AI processing flow
# Use Flask to receive Webhook, call OpenAI to process
# ============================================

from flask import Flask, request, jsonify
import openai
import json

# Initialize Flask app
app = Flask(__name__)

# Configure OpenAI (replace with your API Key)
openai.api_key = "sk-your-api-key-here"

def process_with_ai(content: str) -> str:
    """
Use AI to process received content
Here we do a simple "content classification + summary"
    """

    prompt = f"""
Please analyze the following content and do two things:
1. Classification: determine whether it is "problem", "suggestion", or "thanks"
2. Summary: summarize the core content in one sentence

Content:
    {content}

Please return in JSON format, as follows:
    {{
"category": "problem/suggestion/thanks",
"summary": "summary content"
    }}
    """


    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are example's content analysis assistant."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7
    )

    return response.choices[0].message.content


@app.route("/webhook", methods=["POST"])
def webhook_handler():
    """
Endpoint for receiving Webhook
External system sends POST request to this URL
    """

    # Get request data
    data = request.get_json()

    print(f"Received Webhook data: {data}")

    # Extract the content we need (adjust field names based on actual situation)
    # Here we assume the incoming data has a "content" field
    content = data.get("content", "")

    if not content:
        return jsonify({"status": "error", "message": "Missing content field"}), 400

    # Use AI to process content
    try:
        ai_result = process_with_ai(content)
        print(f"AI processing result: {ai_result}")

        # Parse the JSON returned by AI
        parsed_result = json.loads(ai_result)

        # Here you can save the result to a database, send notifications, etc.
        # For demonstration, we just print it out
        category = parsed_result.get("category", "Unknown")
        summary = parsed_result.get("summary", "")

        print(f"Category: {category}")
        print(f"Summary: {summary}")

        # Return success response
        return jsonify({
            "status": "success",
            "category": category,
            "summary": summary
        })

    except Exception as e:
        print(f"Processing error: {e}")
        return jsonify({"status": "error", "message": str(e)}), 500


@app.route("/test", methods=["GET"])
def test_page():
    """
A simple test page to conveniently test the Webhook
    """

    return """
    <html>
        <body>
<h1>Test Webhook</h1>
            <form action="/webhook" method="post">
<textarea name="content" placeholder="Enter test content"></textarea>
                <br>
<button type="submit">Send</button>
            </form>
        </body>
    </html>
    """



if __name__ == "__main__":
    print("Webhook server started at http://localhost:5000")
    print("Webhook address: http://localhost:5000/webhook")
    print("Test page: http://localhost:5000/test")
    app.run(port=5000, debug=True)

After running this server, you can open http://localhost:5000/test in your browser to test, or use curl to send a test request:

Examples

# Send test Webhook request
curl -X POST http://localhost:5000/webhook \
  -H "Content-Type: application/json" \
  -d '{
"content": "example's tutorials are really well written! It would be even better if there were more practical examples of AI workflows."
  }'

If everything works normally, you will see the category and summary returned by AI.

When using Webhooks in production, remember to add a verification mechanism—such as verifying signatures, checking source IPs, and using API Keys. Otherwise, anyone can send requests to your Webhook, which may cause security issues.


Hands-on Project Collection

In this section, we provide three complete practical project ideas, and you can directly apply these templates.

Automatically Generate Daily News Briefings

Goal: Automatically collect industry news every morning, have AI filter and summarize, and send to your email or Slack.

Required tools: n8n/Make/Zapier, RSS feeds, OpenAI, email/Slack.

Workflow steps:

  • 1. Scheduled trigger: trigger at 8 AM every morning.

  • 2. RSS node: read the RSS of several industry media outlets you follow.

  • 3. Deduplication node: filter out duplicate news.

  • 4. OpenAI node: read news one by one and determine whether it is relevant to your industry.

  • 5. OpenAI Node: Summarize relevant news into a digest.

  • 6. OpenAI Node: Compile all the digests into one email, adding a title and lead-in.

  • 7. Email Node: Send it to your inbox.

Prompt example:

请阅读下面这篇新闻的标题和摘要,判断它是否与"AI 技术应用"相关。

只需要回答"是"或"否",不要解释。

新闻标题:{{$json.title}}
新闻摘要:{{$json.summary}}

Automatic Social Media Content Publishing

Goal: Automatically generate multi-platform social media copy based on product updates, and schedule posts after review.

Tools needed: Make/Zapier, Airtable, OpenAI, Buffer/Hootsuite.

Workflow steps:

  • 1. Airtable Trigger: Triggers when you add a "product update" record in Airtable.

  • 2. OpenAI Node: Generate Weibo copy based on the product update (lively style).

  • 3. OpenAI Node: Generate LinkedIn copy based on the product update (professional style).

  • 4. OpenAI Node: Generate Twitter copy based on the product update (concise style).

  • 5. Airtable Node: Write the copy for the three platforms into the "Pending Review" table.

  • 6. Slack Node: Notify you that there is new content pending review.

  • 7. (After manual review) Buffer Node: Schedule posts to each platform.

This workflow is automated yet retains the control of human review—after all, social media is directly customer-facing, so a final check is still necessary.

Automatic Customer Feedback Classification

Goal: After receiving customer feedback, AI automatically classifies it, analyzes sentiment, and assigns it to the relevant person in charge.

Tools needed: n8n, Typeform/form tool, OpenAI, Airtable, Slack.

Workflow steps:

  • 1. Webhook Trigger: Triggers when a customer submits feedback on the website.

  • 2. OpenAI Node: Analyze the sentiment of the feedback (positive/neutral/negative).

  • 3. OpenAI Node: Classify the feedback type (Bug/Feature request/Usage issue/Thanks).

  • 4. OpenAI Node: Extract keywords and priority.

  • 5. Airtable Node: Save all the information to the feedback database.

  • 6. Conditional branch: If it's negative feedback with high priority, follow the urgent flow; otherwise, follow the normal flow.

  • 7. Slack Node: Notify the technical lead of urgent feedback, and notify customer service of normal feedback.

  • 8. OpenAI Node: Generate a polite auto-reply thanking the customer for their feedback.

9. Email Node: Send the auto-reply to the customer.

This workflow lets customers receive a reply immediately while enabling the team to respond quickly to important issues internally.

A principle for designing workflows:First automate mechanical tasks like "collecting, organizing, and distributing," and leave "judgment, decision-making, and creativity" to humans.Don't try to let AI make all decisions; human-machine collaboration works best.


Comparison Summary of Three Tools

We've made a comprehensive comparison of the three mainstream tools—n8n, Make, and Zapier—to help you choose:

Comparison itemn8nMakeZapier
Open sourceYesnono
Self-hostedSupportedNot supportedNot supported
Free planCompletely free when self-hostedFree version limits number of operationsFree version limits number of Zaps
Number of connected appsHundredsThousands6000+
Interface styleVisual canvasPolished canvasStep forms
Learning curveMediumRelatively lowLowest
Enterprise featuresRequires paid versionCompleteComplete
Technical barrierSlightly higher (self-hosting)LowLowest
Target audienceDevelopers, technical teamsSMBs, teamsIndividuals, beginners
Other extensions