DEV Community: Raizan

Temporal vs Make vs Zapier for API automation

Raizan — Tue, 09 Jun 2026 08:00:45 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting
Namecheap if domain needed
DigitalOcean as alternative
API documentation for your services (Stripe, Shopify, GitHub, etc.)
Basic Node.js knowledge (optional but helpful)
A code editor like VS Code

The Core Differences
Temporal: The Enterprise Orchestrator
Make: The Visual Mid-Market Solution
Zapier: The No-Code Leader
Building Your First API Automation
Performance Benchmarks and Real Costs
When to Use Each Platform
Getting Started

The Core Differences

I've spent the last three years shipping automation workflows across multiple platforms, and I can tell you that the "best" solution depends entirely on what you're automating. Temporal, Make, and Zapier occupy very different lanes.

Temporal is a workflow engine for developers who want deterministic, scalable, long-running processes. Think microservices orchestration. Make (formerly Integromat) sits in the visual mid-market space—it's more flexible than Zapier but requires more setup than Temporal. Zapier is the household name: simple, fast to deploy, but hits a ceiling when you need complex branching logic or custom code.

The fundamental trade-off: code flexibility vs. setup speed. I'll walk you through each.

Temporal: The Enterprise Orchestrator

Temporal is a time-travel capable workflow orchestrator. That's not a marketing gimmick—it means you can pause, replay, and debug workflows as if you have a video recording of execution.

If you're building microservices that need resilience, retries with exponential backoff, or complex state machines, Temporal is your answer. It's what companies like Stripe and Snap use for critical infrastructure.

Setting Up Temporal Locally

First, spin up the Temporal server via Docker:

git clone https://github.com/temporalio/docker-compose.git
cd docker-compose
docker-compose up

This runs the Temporal server on localhost:7233 and the UI on localhost:8080.

Now create a workflow definition:

import {
  proxyActivities,
  defineSignal,
  defineQuery,
  setHandler,
  workflowInfo,
} from "@temporalio/workflow";
import * as activities from "./activities";

const { callStripeAPI, logTransaction, notifySlack } = proxyActivities<
  typeof activities
>({
  startToCloseTimeout: "10 minutes",
});

export interface OrderData {
  orderId: string;
  amount: number;
  email: string;
  retryCount: number;
}

export const orderProcessWorkflow = async (order: OrderData) => {
  let retries = 0;
  const maxRetries = 3;

  while (retries < maxRetries) {
    try {
      const chargeResult = await callStripeAPI({
        amount: order.amount,
        email: order.email,
        orderId: order.orderId,
      });

      await logTransaction({
        orderId: order.orderId,
        status: "completed",
        transactionId: chargeResult.id,
        timestamp: new Date().toISOString(),
      });

      await notifySlack({
        channel: "#orders",
        message: `Order ${order.orderId} processed successfully`,
      });

      return { success: true, transactionId: chargeResult.id };
    } catch (error) {
      retries++;
      if (retries >= maxRetries) {
        await notifySlack({
          channel: "#alerts",
          message: `Order ${order.orderId} failed after ${maxRetries} retries`,
        });
        throw new Error(`Max retries exceeded for order ${order.orderId}`);
      }

      // Temporal automatically handles exponential backoff
      await new Promise((resolve) => setTimeout(resolve, 2000 * retries));
    }
  }
};

Now define the activities (the actual work):

import Stripe from "stripe";
import axios from "axios";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY || "", {
  apiVersion: "2023-10-16",
});

export async function callStripeAPI(chargeData: {
  amount: number;
  email: string;
  orderId: string;
}) {
  const charge = await stripe.charges.create({
    amount: Math.round(chargeData.amount * 100),
    currency: "usd",
    source: "tok_visa",
    receipt_email: chargeData.email,
    metadata: { orderId: chargeData.orderId },
  });

  return {
    id: charge.id,
    status: charge.status,
    amount: charge.amount,
  };
}

export async function logTransaction(data: {
  orderId: string;
  status: string;
  transactionId: string;
  timestamp: string;
}) {
  const response = await axios.post("http://localhost:3000/api/transactions", {
    orderId: data.orderId,
    status: data.status,
    transactionId: data.transactionId,
    timestamp: data.timestamp,
  });

  return response.data;
}

export async function notifySlack(data: {
  channel: string;
  message: string;
}) {
  const response = await axios.post(process.env.SLACK_WEBHOOK_URL || "", {
    channel: data.channel,
    text: data.message,
  });

  return response.data;
}

Start a worker to execute these workflows:

import { Worker } from "@temporalio/worker";
import * as activities from "./activities";
import * as workflows from "./workflows";

async function main() {
  const worker = await Worker.create({
    workflowsPath: require.resolve("./workflows"),
    activitiesPath: require.resolve("./activities"),
    taskQueue: "order-processing",
    workflowRunner: "es-modules",
  });

  console.log("Worker started on task queue: order-processing");
  await worker.run();
}

main().catch(console.error);

Temporal shines here because if activity fails, it retries intelligently. If your worker crashes mid-execution, it resumes from where it left off. No lost state.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

Make: The Visual Mid-Market Solution

Make sits between Zapier's simplicity and Temporal's code-heavy power. It's built for teams that need complex workflows but can't justify a full engineering team.

I prefer Make for APIs that need conditional logic, data transformation, and error handling—without writing TypeScript. The visual builder is honest about what code would look like.

Building an API Orchestration Workflow in Make

Here's a practical example: sync customer data from Shopify to a custom API, then log to Google Sheets on success or Slack on failure.

Step 1: Shopify Trigger
Set the trigger to "New Customer" with filter: accepts_marketing == true

Step 2: Call Your Custom API
In the HTTP module, configure:

URL: https://api.yourcompany.com/v1/sync-customer
Method: POST
Headers:
  Authorization: Bearer YOUR_API_TOKEN
  Content-Type: application/json

Body (raw):
{
  "shopify_id": "{{trigger.id}}",
  "email": "{{trigger.email}}",
  "first_name": "{{trigger.first_name}}",
  "last_name": "{{trigger.last_name}}",
  "phone": "{{trigger.phone}}",
  "created_at": "{{trigger.created_at}}"
}

Step 3: Conditional Routing
After the HTTP call, use a Router:

If {{200 in http.status}}: continue to Google Sheets
Else: send to Slack alert

Step 4: Log to Google Sheets on Success

Spreadsheet: Customers
Worksheet: Active Syncs
Values:
  Column A (Timestamp): {{now}}
  Column B (Customer ID): {{trigger.id}}
  Column C (Email): {{trigger.email}}
  Column D (API Response): {{http.data.customer_id}}

Step 5: Slack Alert on Failure

Message Text: ⚠️ Failed to sync Shopify customer {{trigger.id}}
Error: {{http.error}}
Email: {{trigger.email}}

Make's JSON transformer becomes useful here. If Shopify sends nested data you need to flatten:

{
  "customer_id": "{{trigger.id}}",
  "profile": {
    "email": "{{trigger.email}}",
    "marketing_consent": {{trigger.accepts_marketing}}
  },
  "source": "shopify"
}

The strength of Make is that you can test each module individually, see real data flowing, and iterate without redeploying anything. For teams shipping B2B integrations, this speeds up development by weeks.

Zapier: The No-Code Leader

Zapier remains the fastest to production if your workflow is linear: trigger → transform → action. It's what non-technical teams use, and for good reason.

Building a Simple Zapier Zap

Trigger: "New email in Gmail with label 'leads'"
Action 1: Parse email subject and body via Formatter
Action 2: Create contact in HubSpot
Action 3: Send Slack notification

This takes 10 minutes. No Docker, no code, no infrastructure.

But here's the limitation: if you need to call your custom API, retry on specific error codes, or implement complex branching, Zapier becomes clunky. You'll hit Code by Zapier (their JavaScript sandbox), which is underpowered compared to a proper runtime.

If you're comparing Zapier to other platforms, I'd recommend reading my guide on Budibase vs n8n vs Retool for API workflows because the landscape has shifted—n8n now offers the simplicity of Zapier with the flexibility of Temporal, sitting right in the middle for most teams.

Building Your First API Automation

Let me walk you through a complete example that works across all three platforms: a GitHub webhook that creates Jira tickets, logs to a database, and posts to Discord.

Using n8n (The Practical Middle Ground)

I'm using n8n Cloud here because it's hosted by default, but you can self-host on Hetzner VPS or DigitalOcean if you prefer.

Workflow JSON:

{
  "name": "GitHub to Jira to Discord",
  "nodes": [
    {
      "parameters": {
        "path": "github-webhook",
        "protocol": "https",
        "option": "sourceUrl"
      },
      "name": "GitHub Webhook",
      "type": "n8n-nodes-base.webhookTrigger",
      "typeVersion": 1,
      "position": [250, 300],
      "webhookId": "auto

Originally published on Automation Insider.

Zapier vs n8n vs Make: Enterprise Automation Costs

Raizan — Sat, 06 Jun 2026 08:00:47 +0000

What You'll Need

n8n Cloud or self-hosted n8n (for cost-effective automation)
Hetzner VPS or Contabo VPS if self-hosting n8n
DigitalOcean as an alternative hosting provider
Zapier account (for comparison)
Make.com account (for comparison)
A spreadsheet or calculator to track your workflow volumes and costs

The Real Cost Breakdown
Zapier's Pricing Model and Hidden Costs
n8n's Self-Hosted vs Cloud Strategy
Make.com's Deceptive Task Counting
Running the Numbers: A Real-World Scenario
When to Use Each Platform
Getting Started

The Real Cost Breakdown

I've been building workflow automation systems for three years now, and the number one question clients ask isn't "which platform is best?" It's "why am I paying so much for something so simple?"

The reason? Most automation platforms deliberately obscure their true costs through task counting, execution limits, and feature paywalls. You think you're getting a $29/month solution until your workflows hit 10,000 operations and suddenly you're looking at enterprise pricing.

Here's what nobody tells you: the platform you choose matters far less than understanding how each one counts your work. A simple Zapier integration at $600/year can cost you $3,600/year on Make.com if you don't know their math. Meanwhile, a self-hosted n8n Cloud setup costs $0 to $300/month depending on your tolerance for DevOps.

Let me walk you through the actual numbers so you can make a decision based on your real workflow volume, not marketing spin.

Zapier's Pricing Model and Hidden Costs

Zapier charges per "task." Here's what counts as a task: every action taken by your Zap. If you have a trigger that finds 50 records and updates each one, that's 50 tasks. If your Zap runs 100 times a day, you're looking at 3,000 tasks monthly.

Their pricing tiers:

Free: 100 tasks/month
Basic: $29/month (750 tasks)
Professional: $99/month (2,000 tasks)
Advanced: $299/month (15,000 tasks)
Enterprise: Custom pricing

The hidden cost? You also pay for premium apps. Want to integrate with Slack, Google Sheets, or HubSpot beyond basic actions? Add $5–30/month per premium integration. Need API webhooks? That's on the Professional tier and up.

Real scenario: You want to sync CRM leads to email sequences, then log responses back to your spreadsheet. That's three apps (Zapier's premium for each usually). You're already at $99–149/month just for access, then your 5,000 monthly tasks put you on the $299 Advanced plan.

Total: $299–349/month = $3,588–4,188/year.

n8n's Self-Hosted vs Cloud Strategy

This is where the math gets interesting. n8n Cloud is Zapier's direct competitor on pricing. They charge per workflow execution:

Free Cloud: 1,000 executions/month
Standard Cloud: $50/month (40,000 executions)
Professional Cloud: $200/month (200,000 executions)
Enterprise Cloud: Custom

But here's the real power move: self-hosting. If you run n8n on a Hetzner VPS or Contabo VPS at $5–12/month, your licensing cost is $0. You own the entire platform.

The catch? You're responsible for uptime, backups, and security updates. For most small teams, that's fine. For enterprise operations handling critical customer data, Zapier's managed infrastructure is actually worth the cost.

Self-hosted cost: $60–144/year + your time
n8n Cloud cost: $200–2,400/year depending on execution volume

If you're doing under 50,000 monthly executions, self-hosted wins. Above that, cloud pricing makes sense.

Make.com's Deceptive Task Counting

Make.com uses "operations" instead of tasks, and this is where they're genuinely confusing on purpose.

Their pricing:

Free: 1,000 operations/month
Standard: $9.99/month (10,000 ops)
Pro: $39.99/month (100,000 ops)
Teams: $99/month (unlimited ops, limited to 3 users)
Enterprise: Custom

The problem: one operation is one HTTP request, one database write, one data transformation. A single scenario can generate 10–20 operations before you even execute it. A webhook-triggered flow that reads a database, transforms data, and posts to three services? That's potentially 25+ operations per execution.

I've seen scenarios where the estimated operation count was 50, and actual execution was 150. Their operation counter isn't transparent, and they overrun your quota regularly.

Honest comparison: A flow counting as 1,000 operations in Make.com is probably 5,000 operations in reality.

Running the Numbers: A Real-World Scenario

Let me show you an actual workflow I built for a SaaS client: lead capture, CRM sync, email sequence enrollment, and reporting dashboard update.

This workflow executes 500 times per day (15,000/month). Here's the cost:

Zapier:

Advanced plan (15,000 tasks): $299/month
HubSpot premium app: $20/month
Gmail premium: $10/month
Google Sheets premium: $10/month
Total: $339/month = $4,068/year

Make.com:

Pro plan (100,000 ops): $39.99/month
Actual operations per execution: ~80
500 × 80 = 40,000/month (within Pro tier)
Total: $39.99/month = $479.88/year

Wait, that seems too cheap. Let me recalculate. Actual scenario included error handling and retries. Average operations per execution hit 120:

500 × 120 = 60,000/month
Still fits Pro tier
Still: $39.99/month

But then the client hit rate limits from their API. Auto-retries triggered. Suddenly they hit 150,000 operations in month three.

Month 3: $99/month (Teams tier for unlimited)

They've now discovered Make.com's dirty secret: you can appear cheap until you can't, then you hit unlimited pricing with no way back.

n8n Cloud (same scenario):

Standard plan (40,000 executions): $50/month
They executed 15,000/month, fit easily
Total: $50/month = $600/year

n8n Self-Hosted (on Hetzner VPS $7/month):

VPS: $7/month
License: $0/month
Total: $7/month = $84/year

The client chose self-hosted. If you want to understand how to run multiple automation systems this way, I've documented the full setup for running 3 automated systems on a single $7/month VPS.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

When to Use Each Platform

Use Zapier if:

You need 100% managed infrastructure with SLAs
Your execution volume is under 5,000/month
You're already in the Zapier ecosystem
Your team isn't technical enough to manage self-hosted systems

Use n8n Cloud if:

You execute 10,000–200,000 operations monthly
You want more control than Zapier offers
You need custom code and advanced error handling
You value long-term cost predictability

Use n8n Self-Hosted if:

You execute more than 50,000 operations monthly
You have basic DevOps knowledge
You're willing to manage uptime and security
You want zero licensing costs

Avoid Make.com if:

You care about transparent pricing
You want to avoid surprise overage costs
You need consistent month-to-month budgeting

I've compared n8n with two other powerful no-code platforms in my guide on Budibase vs n8n vs Retool for API workflows, which goes deeper into feature sets beyond just cost.

There's also a parallel discussion in the world of backend automation: Temporal vs n8n vs Zapier API automation costs covers the enterprise serverless comparison if you're building production systems at scale.

Getting Started

Option 1: Start on n8n Cloud

Visit n8n Cloud, create an account, and build your first workflow free. Their UI is intuitive. You'll have something working in 20 minutes.

{
  "nodes": [
    {
      "parameters": {
        "url": "https://api.example.com/leads",
        "method": "GET",
        "authentication": "oAuth2"
      },
      "name": "Fetch Leads",
      "type": "n8n-nodes-base.httpRequest",
      "position": [
        250,
        300
      ]
    },
    {
      "parameters": {
        "spreadsheet": "your-sheet-id",
        "range": "Sheet1!A:E",
        "operation": "append"
      },
      "name": "Append to Google Sheets",
      "type": "n8n-nodes-base.googleSheets",
      "position": [
        600,
        300
      ]
    }
  ],
  "connections": {
    "Fetch Leads": {
      "main": [
        [
          {
            "node": "Append to Google Sheets",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

Option 2: Self-Host on Hetzner

Rent a VPS from Hetzner VPS ($7/month). Install n8n via Docker:

ssh root@your-hetzner-ip
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
docker run -d --name n8n -p 5678:5678 -e NODE_ENV=production -e WEBHOOK_TUNNEL_URL=https://your-domain.com/ -v n8n_data:/home/node/.n8n n8nio/n8n

You'll need a domain. Get one from Namecheap if you don't have one.

Configure your domain to point to the Hetzner IP, then set up SSL with Let's Encrypt:

apt-get update
apt-get install certbot
certbot certonly --standalone -d your-domain.com

Access n8n at https://your-domain.com:5678 and create

Originally published on Automation Insider.

Temporal vs n8n vs Zapier API Automation Costs

Raizan — Wed, 03 Jun 2026 08:00:31 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for self-hosted deployment
DigitalOcean as an alternative hosting option
Basic understanding of APIs and workflow concepts
Spreadsheet software to track and compare costs

What You'll Need
Understanding the Three Platforms
Temporal: The Enterprise Choice
n8n: The Flexible Middle Ground
Zapier: The Simple Starter
Direct Cost Comparison Framework
Building Your Own Cost Calculator
Reducing Hidden Costs with Self-Hosted Solutions
Getting Started

Understanding the Three Platforms

I've been automating workflows professionally for five years now, and the question I hear most often is: "Which platform actually saves me money?" The answer isn't as straightforward as comparing monthly subscription rates. Temporal, n8n, and Zapier operate on fundamentally different models, and understanding those models is critical before you pick one.

Temporal is a workflow orchestration engine designed for complex, long-running tasks. It's what you'd use if you need bulletproof reliability and state management across distributed systems. n8n is a visual workflow builder with both cloud and self-hosted options, making it incredibly flexible for teams of any size. Zapier is the SaaS king—simple, mainstream, and expensive at scale.

Let me break down exactly what you're paying for with each one.

Temporal: The Enterprise Choice

Temporal isn't for everyone. Its pricing model is built around task executions, not workflows. Each time a task runs, you're being billed.

Here's what you're actually paying with Temporal:

Temporal Cloud Standard: $0.25 per 1,000 action executions
Storage: $0.10 per GB-month
Retention: Additional fees for extended workflow history

Let's say you run a data pipeline that processes 10 million records monthly, with 5 actions per record. That's 50 million executions—costing you $12,500/month in compute alone.

But here's the thing: Temporal is built for scenarios where you need that level of control. You're getting:

Distributed task execution
Automatic retries and exponential backoff
State machine reliability
Guaranteed execution semantics

If you're building microservices that must never lose data, Temporal is worth every penny. If you're automating simple integrations, you're throwing money away.

When to use Temporal:

High-volume event processing (millions of tasks/month)
Mission-critical workflows requiring guaranteed execution
Complex retry logic and state management needs

Cost at scale: $5,000–$50,000+/month for enterprise workloads

n8n: The Flexible Middle Ground

This is where I spend most of my time. n8n Cloud pricing is refreshingly transparent:

Free tier: Up to 20,000 executions/month
Pro: $20/month (500k executions)
Business: $400/month (50 million executions)
Enterprise: Custom pricing

Here's a real example from a client project: We built a lead generation workflow that integrated Zapier (yes, we were using them alongside n8n), Google Sheets, and a custom API. The workflow ran 50,000 times monthly.

With n8n Pro at $20/month, we were golden. The same workflow on Zapier would've cost $99–$299/month depending on their plan structure.

But here's where self-hosting saves you serious money. If you host n8n on Hetzner VPS ($3–$20/month depending on specs), you get unlimited executions. That's the real unlock.

I've written extensively about self-hosted workflow automation vs cloud Zapier alternatives, and the math is brutal in Zapier's favor if you're running high-volume operations.

Self-hosted n8n breakdown:

VPS cost: $10/month (Hetzner)
Management overhead: ~5 hours setup, ~2 hours/month maintenance
Unlimited executions: Priceless

A 100,000-execution/month workflow costs $90/month on n8n Cloud, but $10/month self-hosted.

When to use n8n:

Flexible integrations across 400+ apps
Teams wanting both cloud convenience and self-hosted control
Workflows under 500k executions/month (Cloud) or unlimited (self-hosted)

Cost range: $0 (self-hosted, labor-only) to $400/month (Cloud Business)

Zapier: The Simple Starter

Zapier's pricing is task-based, not execution-based. That distinction matters.

Free: 100 tasks/month
Starter: $19.99/month (750 tasks)
Professional: $49/month (2,000 tasks)
Business: $99/month (5,000 tasks)
Enterprise: Custom

A "task" in Zapier terminology is a single action execution. So if you have a Zap that triggers on new Google Form submissions and creates a Salesforce lead, that's 2 tasks per submission.

Here's where Zapier gets expensive fast: A workflow with 3 actions that runs 10,000 times monthly uses 30,000 tasks. That puts you at the Enterprise tier, meaning you're probably negotiating custom pricing in the $1,000+/month range.

Zapier's strength is onboarding speed. You can build a working integration in 10 minutes. Their weakness is cost transparency—the pricing page doesn't tell you what Enterprise actually costs for your use case.

I've helped reduce SaaS bills with self-hosted alternatives by moving Zapier workloads to n8n, saving clients $500–$2,000/month.

When to use Zapier:

Simple 1-2 step automations
<1,000 tasks/month workflows
Maximum execution speed/no setup time
Non-technical teams

Cost range: $20–$500+/month (typically)

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

Direct Cost Comparison Framework

Let me build a practical comparison model. I'll use three real-world scenarios.

Scenario 1: Lead capture (10,000/month executions)

Platform	Monthly Cost	Annual Cost
Zapier (Starter)	$19.99	$240
n8n Cloud (Free tier: 20k included)	$0	$0
n8n Self-hosted (Hetzner)	$10	$120
Temporal	$2.50	$30

Winner: n8n Cloud (free)

Scenario 2: Mid-scale automation (100,000/month executions)

Platform	Monthly Cost	Annual Cost
Zapier (Business)	$99	$1,188
n8n Cloud (Pro)	$20	$240
n8n Self-hosted (Hetzner)	$10	$120
Temporal	$25	$300

Winner: n8n Self-hosted

Scenario 3: Enterprise scale (10 million/month executions)

Platform	Monthly Cost	Annual Cost
Zapier (Enterprise)	$1,500–$5,000	$18,000–$60,000
n8n Cloud (Business)	$400	$4,800
n8n Self-hosted (Contabo Business)	$50	$600
Temporal	$2,500	$30,000

Winner: n8n Self-hosted

Building Your Own Cost Calculator

Rather than rely on vendor claims, I built a simple script to calculate your actual costs based on execution count and action complexity. You can adapt this for your numbers:

const calculateCosts = (monthlyExecutions, actionsPerExecution) => {
  const totalActions = monthlyExecutions * actionsPerExecution;

  // Zapier pricing tiers
  let zapierCost = 0;
  if (totalActions <= 100) zapierCost = 0;
  else if (totalActions <= 750) zapierCost = 19.99;
  else if (totalActions <= 2000) zapierCost = 49;
  else if (totalActions <= 5000) zapierCost = 99;
  else zapierCost = 1500; // Enterprise estimate

  // n8n Cloud pricing tiers
  let n8nCloudCost = 0;
  if (totalActions <= 20000) n8nCloudCost = 0;
  else if (totalActions <= 500000) n8nCloudCost = 20;
  else if (totalActions <= 50000000) n8nCloudCost = 400;
  else n8nCloudCost = 1500; // Enterprise estimate

  // n8n Self-hosted (Hetzner CX11: $5.99/month)
  const n8nSelfHostedCost = 5.99;

  // Temporal pricing (0.25 per 1000 actions + storage)
  const temporalActionsCost = (totalActions / 1000) * 0.25;
  const temporalStorageCost = 10; // estimate for moderate storage
  const temporalTotal = temporalActionsCost + temporalStorageCost;

  return {
    monthlyExecutions,
    actionsPerExecution,
    totalActions,
    zapierMonthly: zapierCost,
    zapierAnnual: zapierCost * 12,
    n8nCloudMonthly: n8nCloudCost,
    n8nCloudAnnual: n8nCloudCost * 12,
    n8nSelfHostedMonthly: n8nSelfHostedCost,
    n8nSelfHostedAnnual: n8nSelfHostedCost * 12,
    temporalMonthly: temporalTotal,
    temporalAnnual: temporalTotal * 12,
  };
};

const result = calculateCosts(50000, 3);
console.log("Workflow: 50,000 monthly executions, 3 actions each");
console.log(`Total actions: ${result.totalActions}`);
console.log(`Zapier: $${result.zapierMonthly}/month ($${result.zapierAnnual}/year)`);
console.log(`n8n Cloud: $${result.n8nCloudMonthly}/month ($${result.n8nCloudAnnual}/year)`);
console.log(`n8n Self-hosted: $${result.n8nSelfHostedMonthly}/month ($${result.n8nSelfHostedAnnual}/year)`);
console.log(`Temporal: $${result.temporalMonthly.toFixed(2)}/month ($${result.temporalAnnual.toFixed(2)}/year)`);

// Output:
// Workflow: 50,000 monthly executions, 3 actions each
// Total actions: 150,000
// Zapier: $99/month ($1,

Originally published on Automation Insider.

Budibase vs n8n vs Retool for API workflows

Raizan — Tue, 02 Jun 2026 08:00:44 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting
Namecheap if domain needed
DigitalOcean as alternative
API credentials (Stripe, Slack, or similar for testing)
Basic understanding of REST APIs and webhooks

The Core Difference
n8n for Power Users
Budibase for Full-Stack Speed
Retool for Internal Tools
Comparing API Workflow Capabilities
Real-World Implementation
Getting Started

The Core Difference

I've spent the last three years building API automation workflows, and the question I get asked most isn't "which one is best?" but rather "which one should I choose for my specific use case?" The honest answer: it depends on whether you're building automation logic, user-facing applications, or internal dashboards.

n8n, Budibase, and Retool occupy different lanes. n8n is a workflow orchestration engine. Budibase is a low-code full-stack platform. Retool is a rapid internal tool builder. They can overlap, but their DNA is different.

Here's my breakdown:

n8n: API workflows, data pipelines, background jobs, integration glue
Budibase: Complete applications with databases, auth, and APIs bundled in
Retool: CRUD interfaces for internal teams that connect to existing databases

If you're automating APIs—connecting services, transforming data, triggering actions based on webhooks—you want n8n. If you need to build an application with forms, databases, and user authentication, Budibase wins. If you're an ops team building dashboards to query your production database, Retool is faster.

n8n for Power Users

I use n8n Cloud for 80% of my automation. It's built for API workflows specifically. You chain nodes together—HTTP requests, data transformations, conditional logic—and it handles the execution layer.

Why n8n dominates for APIs:

Native HTTP node with retry logic and OAuth
Cron triggers for scheduled jobs
Webhook triggers that can accept and parse JSON
Advanced data transformation without coding
Error handling and branching logic

Here's a real workflow I built to sync Stripe payments to a custom database:

{
  "nodes": [
    {
      "parameters": {
        "path": "webhooks/stripe",
        "options": {}
      },
      "id": "webhook_trigger",
      "name": "Webhook Trigger",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [100, 300]
    },
    {
      "parameters": {
        "functionCode": "return {\n  transactionId: $json.data.object.id,\n  amount: $json.data.object.amount / 100,\n  currency: $json.data.object.currency,\n  status: $json.data.object.status,\n  customerEmail: $json.data.object.customer_email,\n  timestamp: new Date($json.data.object.created * 1000).toISOString()\n};"
      },
      "id": "transform_stripe",
      "name": "Transform Stripe Data",
      "type": "n8n-nodes-base.code",
      "typeVersion": 1,
      "position": [300, 300]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://api.yourdb.com/transactions",
        "authentication": "genericCredentialType",
        "genericCredentialType": {
          "credentialType": "httpHeaderAuth",
          "credentialDetails": {
            "name": "Authorization",
            "value": "Bearer YOUR_API_KEY"
          }
        },
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {
              "name": "transactionId",
              "value": "={{ $json.transactionId }}"
            },
            {
              "name": "amount",
              "value": "={{ $json.amount }}"
            },
            {
              "name": "currency",
              "value": "={{ $json.currency }}"
            },
            {
              "name": "status",
              "value": "={{ $json.status }}"
            },
            {
              "name": "customerEmail",
              "value": "={{ $json.customerEmail }}"
            },
            {
              "name": "timestamp",
              "value": "={{ $json.timestamp }}"
            }
          ]
        }
      },
      "id": "http_request",
      "name": "POST to Database",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [500, 300]
    },
    {
      "parameters": {
        "fieldToMatchOn": "status",
        "value": "succeeded",
        "type": "string"
      },
      "id": "if_succeeded",
      "name": "Check if Payment Succeeded",
      "type": "n8n-nodes-base.if",
      "typeVersion": 1,
      "position": [700, 200]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
        "sendBody": true,
        "bodyContent": "{\n  \"text\": \"Payment received from ${{ $json.customerEmail }}: ${{ $json.amount }} {{ $json.currency }}\"\n}"
      },
      "id": "slack_notification",
      "name": "Notify Slack",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [900, 200]
    }
  ],
  "connections": {
    "webhook_trigger": {
      "main": [
        [
          {
            "node": "transform_stripe",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "transform_stripe": {
      "main": [
        [
          {
            "node": "http_request",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "http_request": {
      "main": [
        [
          {
            "node": "if_succeeded",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "if_succeeded": {
      "main": [
        [
          {
            "node": "slack_notification",
            "type": "main",
            "index": 0
          }
        ],
        []
      ]
    }
  }
}

This workflow:

Listens for Stripe webhook events
Transforms the raw Stripe payload into clean fields
POSTs the transaction to your database
Checks if payment succeeded
Sends a Slack notification on success

You can run this on n8n Cloud (managed) or self-host on a Hetzner VPS for full control. I've documented how to run multiple automation systems on a single budget VPS in my guide on how to run 3 automated systems on a single $7/month VPS, which is relevant if you're cost-conscious.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

Budibase for Full-Stack Speed

Budibase is different. It's not just workflow automation—it's a full application platform. You get a database, UI builder, backend logic, and API all in one.

Use Budibase when you need:

A web application with user authentication
Database schema design (PostgreSQL, MongoDB, MySQL)
User-facing forms and data entry
Generated REST APIs from your data

Here's a simple Budibase app that builds an admin dashboard connected to PostgreSQL:

// Budibase data source configuration
{
  "name": "payments_db",
  "type": "postgres",
  "config": {
    "host": "db.example.com",
    "port": 5432,
    "database": "payments",
    "user": "admin",
    "password": "secure_password",
    "ssl": true
  }
}

Then you'd create a query:

SELECT 
  id,
  customer_email,
  amount,
  currency,
  status,
  created_at
FROM transactions
WHERE status = $1
ORDER BY created_at DESC
LIMIT $2

Bind that query to a table component, add filters for status and date range, and you have a fully functional dashboard. Budibase auto-generates the REST endpoints too—useful if external systems need to read this data.

The key difference from n8n: Budibase is where your users interact. n8n is where your systems talk to each other.

Retool for Internal Tools

Retool is laser-focused on one thing: building internal dashboards and admin panels fast. If your team needs to query production databases, run bulk operations, or monitor systems, Retool beats custom coding by months.

Here's what a Retool query looks like:

// PostgreSQL query in Retool
select * from users 
where created_at > now() - interval '7 days'
and status = {{ statusFilter.value }}
order by created_at desc;

You drag that query onto a page, bind it to a table, add a status dropdown filter, and deploy. Takes 15 minutes.

The tradeoff: Retool doesn't have native workflow automation. No cron jobs, no multi-step orchestration. It's read/write for databases, not API orchestration.

Comparing API Workflow Capabilities

Here's the honest comparison:

Feature	n8n	Budibase	Retool
HTTP requests & webhooks	✅ Native	✅ Via API query	✅ Via API query
Scheduled jobs (cron)	✅ Yes	⚠️ Limited	❌ No
Multi-step workflows	✅ Built-in	⚠️ Scripting only	❌ No
Error retry logic	✅ Configurable	⚠️ Manual scripting	❌ No
User authentication	❌ Not primary	✅ Built-in	✅ Built-in
Database UI	❌ No	✅ Yes	✅ Yes
Self-hosting	✅ Easy	✅ Easy	✅ Docker
Learning curve	Medium	Medium	Low

If you need API orchestration with branching logic, error handling, and scheduled execution, n8n is unmatched. If you're building user-facing features, Budibase or Retool work better.

For understanding webhook architecture in particular, check my guide on [

Originally published on Automation Insider.

Airbyte vs n8n vs Fivetran: ETL Pipelines

Raizan — Sun, 31 May 2026 08:00:34 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting
Namecheap if domain needed
DigitalOcean as alternative

The Core Differences
Airbyte Deep Dive
n8n for ETL Workflows
Fivetran's Enterprise Approach
Hands-On Comparison
Getting Started

The Core Differences

I've been building data pipelines for five years now, and the "which ETL tool" question keeps coming up. The answer? It depends—but let me break down why these three platforms diverge in ways that matter.

Airbyte is the open-source movement's answer to expensive proprietary ETL. It's built for data engineers who want control and transparency. n8n started as workflow automation but evolved into a capable ETL platform with a visual builder that makes complex logic accessible. Fivetran is the enterprise play—fully managed, pre-built connectors, and you pay for convenience.

Here's the practical reality: if you're bootstrapped or learning, Airbyte or n8n are your friends. If your company budgeted six figures for data infrastructure, Fivetran's your bet. But cost alone isn't the story. Let me walk you through what actually matters.

Airbyte Deep Dive

Airbyte launched in 2020 and quickly became the darling of the self-hosted ETL crowd. Why? It solved a real problem: data connectors are a nightmare to build from scratch.

I deployed Airbyte on a Hetzner VPS last year and was shocked at how straightforward the connector library is. Out of the box, you get 300+ pre-built connectors for everything from Stripe to Salesforce to PostgreSQL.

The architecture is clean: a Docker-based Airbyte server runs on your infrastructure, manages jobs, and stores metadata. You point it at source and destination databases, define sync schedules, and it handles the rest.

Here's what a minimal Airbyte Docker setup looks like:

git clone https://github.com/airbytehq/airbyte.git
cd airbyte
docker-compose up

That's it. Airbyte runs on localhost:8000 and you configure everything via the web UI. But here's where it gets interesting for developers: you can define custom connectors in Python.

Let me show you a custom Python connector skeleton:

from abc import ABC, abstractmethod
from typing import Any, Iterable, List, Mapping, Optional, Tuple

from airbyte_cdk.models import AirbyteCatalog, AirbyteConnectionStatus, AirbyteMessage, AirbyteStream, SyncMode, Type
from airbyte_cdk.sources import Source


class CustomPostgresConnector(Source):
    def check(self, logger, config: Mapping[str, Any]) -> AirbyteConnectionStatus:
        try:
            import psycopg2
            conn = psycopg2.connect(
                host=config["host"],
                port=config["port"],
                user=config["user"],
                password=config["password"],
                database=config["database"]
            )
            conn.close()
            return AirbyteConnectionStatus(status=Type.SUCCEEDED)
        except psycopg2.Error as e:
            return AirbyteConnectionStatus(status=Type.FAILED, message=str(e))

    def discover(self, logger, config: Mapping[str, Any]) -> AirbyteCatalog:
        import psycopg2
        conn = psycopg2.connect(
            host=config["host"],
            port=config["port"],
            user=config["user"],
            password=config["password"],
            database=config["database"]
        )
        cursor = conn.cursor()
        cursor.execute("""
            SELECT table_name 
            FROM information_schema.tables 
            WHERE table_schema = 'public'
        """)
        tables = cursor.fetchall()
        streams = []

        for table in tables:
            table_name = table[0]
            cursor.execute(f"""
                SELECT column_name, data_type 
                FROM information_schema.columns 
                WHERE table_name = '{table_name}'
            """)
            columns = cursor.fetchall()
            properties = {}
            for col_name, col_type in columns:
                properties[col_name] = {"type": "string"}

            stream = AirbyteStream(
                name=table_name,
                json_schema={
                    "type": "object",
                    "properties": properties
                },
                supported_sync_modes=[SyncMode.full_refresh, SyncMode.incremental]
            )
            streams.append(stream)

        cursor.close()
        conn.close()
        return AirbyteCatalog(streams=streams)

    def read(self, logger, config: Mapping[str, Any], catalog: AirbyteCatalog, state: Optional[Mapping[str, Any]]) -> Iterable[AirbyteMessage]:
        import psycopg2
        import json

        conn = psycopg2.connect(
            host=config["host"],
            port=config["port"],
            user=config["user"],
            password=config["password"],
            database=config["database"]
        )
        cursor = conn.cursor()

        for stream in catalog.streams:
            cursor.execute(f"SELECT * FROM {stream.name}")
            columns = [desc[0] for desc in cursor.description]

            for row in cursor.fetchall():
                record = dict(zip(columns, row))
                yield AirbyteMessage(
                    type=Type.RECORD,
                    record={
                        "stream": stream.name,
                        "data": record,
                        "emitted_at": int(__import__('time').time() * 1000)
                    }
                )

        cursor.close()
        conn.close()

That's a fully functional Airbyte source. Airbyte expects this to be packaged and registered in their connector registry. The benefit? Complete control over how data flows.

Cost reality: Airbyte is free if self-hosted. They offer managed cloud at $0.50 per sync job, which adds up fast if you run hundreds daily. Storage is separate.

When Airbyte wins: You need ultimate control, have a large engineering team, or need custom logic connectors can't provide.

n8n for ETL Workflows

I built my first production n8n workflow in 2022 and immediately saw why people call it "Zapier but actually yours." n8n Cloud gives you hosted workflows, but if you care about data sovereignty—or price—self-host it.

The key difference from Airbyte: n8n is workflow-first, not data-movement-first. You can absolutely use it for ETL, but the mental model is "what operations do I want to chain together?" rather than "how do I sync this database?"

That said, n8n has one advantage Airbyte doesn't: it's a full integration platform. You can transform, validate, and route data in the same platform.

Here's a practical ETL workflow in n8n JSON (this is what the UI generates):

{
  "nodes": [
    {
      "parameters": {
        "host": "postgres.example.com",
        "port": 5432,
        "user": "{{ $env.DB_USER }}",
        "password": "{{ $env.DB_PASSWORD }}",
        "database": "source_db",
        "ssl": true,
        "query": "SELECT id, email, created_at FROM users WHERE created_at > NOW() - INTERVAL '1 day'"
      },
      "name": "Fetch Recent Users",
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2,
      "position": [250, 300],
      "credentials": {
        "postgres": "prod_postgres_creds"
      }
    },
    {
      "parameters": {
        "operation": "create",
        "schema": "public",
        "table": "user_emails",
        "columns": "id,email,created_at",
        "dataToInsert": "={{ $json }}"
      },
      "name": "Insert to Data Warehouse",
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2,
      "position": [550, 300],
      "credentials": {
        "postgres": "warehouse_postgres_creds"
      },
      "dependsOn": ["Fetch Recent Users"]
    },
    {
      "parameters": {
        "operation": "post",
        "url": "https://api.segment.com/v1/batch",
        "authentication": "basicAuth",
        "basicAuth": "segment_auth",
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {
              "name": "batch",
              "value": "={{ $json.map(row => ({ userId: row.id, traits: { email: row.email }, timestamp: row.created_at })) }}"
            }
          ]
        }
      },
      "name": "Send to Segment",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 3,
      "position": [850, 300],
      "dependsOn": ["Insert to Data Warehouse"]
    },
    {
      "parameters": {},
      "name": "Start",
      "type": "n8n-nodes-base.start",
      "typeVersion": 1,
      "position": [50, 300]
    }
  ],
  "connections": {
    "Start": {
      "main": [
        [
          {
            "node": "Fetch Recent Users",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Recent Users": {
      "main": [
        [
          {
            "node": "Insert to Data Warehouse",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Insert to Data Warehouse": {
      "main": [
        [
          {
            "node": "Send to Segment",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

Notice what just happened: we fetched from Postgres, inserted into a data warehouse, and pushed to a third-party API—all in one workflow. Airbyte would require two separate connectors and external orchestration to chain them.

Self-hosting n8n Cloud on a Contabo VPS costs you ~$5-10/month for infrastructure, and the software is free. Managed n8n Cloud starts at $25/month.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

Fivetran's Enterprise Approach

Fivetran is the opposite of DIY. You pay Fivetran thousands per month, and they handle the connectors, transformations, monitoring—everything.

The appeal is real: pre-built connectors for 300+ data sources, automatic schema updates, connectors that just work. No Python,

Originally published on Automation Insider.

Temporal vs n8n vs Airflow Batch Processing

Raizan — Thu, 28 May 2026 08:00:31 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for self-hosting Temporal/Airflow
DigitalOcean as an alternative hosting option
Docker and Docker Compose (free)
Python 3.9+ for Airflow workflows
Node.js 16+ for n8n custom nodes (optional)

Why Batch Processing Matters
Understanding Temporal, n8n, and Airflow
Temporal for Distributed Batch Jobs
n8n's Approach to Batch Processing
Airflow: The Batch Processing Pioneer
Head-to-Head Comparison
Real-World Implementation Examples
Getting Started

Why Batch Processing Matters

I've spent the last three years helping teams move data at scale, and I can tell you: batch processing is the backbone of serious data operations. Whether you're processing daily user exports, running nightly reconciliations, or ingesting thousands of records from a data warehouse, your choice of orchestration tool can make or break your workflow efficiency.

The problem? Everyone claims their tool is best for batch processing. Temporal boasts distributed resilience. Airflow owns the data engineering space. And n8n promises low-code simplicity. So which one actually delivers when you need to process 100,000 records reliably?

This guide cuts through the marketing. I'm walking you through real batch scenarios, actual config code, and honest trade-offs so you can pick the right tool today—not waste six months on the wrong one tomorrow.

Understanding Temporal, n8n, and Airflow

Let me be direct: these three tools solve the same problem in fundamentally different ways.

Temporal is a distributed workflow engine built on Apache Cadence. It's designed for long-running, fault-tolerant operations with built-in replay logic. Think: microservices orchestration at Netflix scale.

n8n is a visual workflow automation platform that's perfect for connecting SaaS tools and APIs without code. You drag, drop, and deploy. It's self-hostable (which I cover in depth in my Self-Hosted Workflow Automation vs Cloud Zapier Alternatives guide), making it enterprise-friendly.

Airflow is Apache's open-source DAG (Directed Acyclic Graph) scheduler, built specifically for data engineering. It's Python-first and has the most mature ecosystem for batch jobs.

For batch processing specifically, they occupy different lanes:

Temporal: Best for complex, distributed batch workflows with strict reliability needs
n8n: Best for mid-scale batch jobs connecting SaaS platforms
Airflow: Best for data engineering pipelines with complex dependencies

Temporal for Distributed Batch Jobs

Temporal's killer feature for batch processing is durability through replay. If your worker crashes mid-batch, Temporal replays from the last checkpoint without reprocessing completed items.

Here's a real batch processor that handles customer data exports:

import * as wf from '@temporalio/workflow';
import type * as activities from './activities';

export async function customerExportBatch(batchId: string, customerIds: string[]) {
  const { processCustomerBatch, uploadToS3, notifyAdmin } = wf.proxyActivities<typeof activities>({
    startToCloseTimeout: '10 minutes',
    retryPolicy: {
      initialInterval: '5 seconds',
      maximumInterval: '1 minute',
      maximumAttempts: 3,
    },
  });

  const chunkSize = 100;
  const chunks: string[][] = [];

  for (let i = 0; i < customerIds.length; i += chunkSize) {
    chunks.push(customerIds.slice(i, i + chunkSize));
  }

  const results: string[] = [];

  for (const chunk of chunks) {
    const result = await processCustomerBatch(batchId, chunk);
    results.push(result);
  }

  const s3Path = await uploadToS3(batchId, results);
  await notifyAdmin(batchId, s3Path);

  return { batchId, processedCount: customerIds.length, s3Path };
}

The activity implementation:

import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import * as fs from 'fs';

const s3 = new S3Client({ region: 'us-east-1' });

export async function processCustomerBatch(batchId: string, customerIds: string[]): Promise<string> {
  const exportData: Record<string, unknown>[] = [];

  for (const customerId of customerIds) {
    const customer = await fetchCustomerFromDB(customerId);
    exportData.push({
      id: customerId,
      name: customer.name,
      email: customer.email,
      createdAt: customer.createdAt,
      lastPurchase: customer.lastPurchase,
    });
  }

  const fileName = `batch-${batchId}-${Date.now()}.json`;
  fs.writeFileSync(fileName, JSON.stringify(exportData, null, 2));

  return fileName;
}

export async function uploadToS3(batchId: string, filePaths: string[]): Promise<string> {
  const s3Paths: string[] = [];

  for (const filePath of filePaths) {
    const fileContent = fs.readFileSync(filePath);
    const key = `exports/${batchId}/${filePath}`;

    const command = new PutObjectCommand({
      Bucket: 'your-bucket-name',
      Key: key,
      Body: fileContent,
    });

    await s3.send(command);
    s3Paths.push(`s3://your-bucket-name/${key}`);
    fs.unlinkSync(filePath);
  }

  return s3Paths.join(', ');
}

export async function notifyAdmin(batchId: string, s3Path: string): Promise<void> {
  console.log(`Batch ${batchId} completed. Files available at: ${s3Path}`);
}

async function fetchCustomerFromDB(customerId: string): Promise<Record<string, unknown>> {
  return {
    name: `Customer ${customerId}`,
    email: `customer${customerId}@example.com`,
    createdAt: new Date().toISOString(),
    lastPurchase: new Date(Date.now() - 86400000).toISOString(),
  };
}

To run this, you deploy with a Worker:

import { Worker } from '@temporalio/worker';
import * as activities from './activities';

async function run() {
  const worker = await Worker.create({
    workflowsPath: require.resolve('./workflows'),
    activities,
    taskQueue: 'batch-processing',
    connection: {
      address: 'temporal.example.com:7233',
    },
  });

  await worker.run();
}

run().catch(err => {
  console.error('Worker failed:', err);
  process.exit(1);
});

Temporal shines here because if your database call fails on customer #7,500, Temporal remembers where you left off. Restart the worker—it picks up at 7,501. No lost work, no duplicates.

n8n's Approach to Batch Processing

n8n handles batch processing differently: it's about connecting existing systems and transforming data visually. You're not writing orchestration logic—you're wiring integrations.

Here's a JSON config for a batch job that exports Stripe customers to Postgres:

{
  "nodes": [
    {
      "parameters": {
        "resource": "customer",
        "operation": "getAll",
        "returnAll": true,
        "options": {}
      },
      "id": "stripe-fetch",
      "name": "Stripe Get All Customers",
      "type": "n8n-nodes-base.stripe",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "mode": "runOnceForAllItems",
        "expression": "={\n  \"id\": $json.id,\n  \"name\": $json.name,\n  \"email\": $json.email,\n  \"created\": $json.created,\n  \"phone\": $json.phone\n}"
      },
      "id": "transform-data",
      "name": "Transform to DB Schema",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.5,
      "position": [550, 300]
    },
    {
      "parameters": {
        "host": "postgres.example.com",
        "database": "analytics",
        "user": "batch_user",
        "password": "{{ $env.POSTGRES_PASS }}",
        "ssl": true,
        "port": 5432
      },
      "id": "postgres-config",
      "name": "Postgres Connection",
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2.4,
      "position": [850, 300],
      "credentials": {
        "postgresCredential": "postgres_prod"
      }
    },
    {
      "parameters": {
        "query": "INSERT INTO customers (id, name, email, created, phone, synced_at) VALUES ($1, $2, $3, to_timestamp($4), $5, NOW()) ON CONFLICT (id) DO UPDATE SET name=$2, email=$3, phone=$5, synced_at=NOW();",
        "queryParams": "=id, name, email, created, phone"
      },
      "id": "upsert-customers",
      "name": "Upsert Customers",
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2.4,
      "position": [850, 450]
    },
    {
      "parameters": {
        "text": "=Batch completed. Synced {{ $node[\"stripe-fetch\"].data.length }} customers to Postgres.",
        "sendTo": "channel",
        "channel": "batch-logs"
      },
      "id": "slack-notify",
      "name": "Notify Slack",
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2.1,
      "position": [1150, 300],
      "credentials": {
        "slackApi": "slack_workspace"
      }
    }
  ],
  "connections": {
    "stripe-fetch": {
      "main": [
        [
          {
            "node": "transform-data",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "transform-data": {
      "main": [
        [
          {
            "node": "upsert-customers",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "upsert-customers": {
      "main": [
        [
          {
            "node": "slack-notify",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

To schedule this daily using n8n's Trigger

Originally published on Automation Insider.

n8n vs Airflow for API workflow automation

Raizan — Wed, 27 May 2026 08:00:30 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for self-hosted deployments
DigitalOcean as an alternative hosting provider
Python 3.8+ (for Airflow)
Basic API knowledge and familiarity with REST endpoints

The Core Difference: When to Pick Each
n8n for Rapid API Workflows
Airflow for Complex DAGs
Hands-On: Building the Same Workflow in Both
Performance, Scaling, and Real Costs
Getting Started

The Core Difference: When to Pick Each

I've spent the last three years automating workflows with both n8n and Airflow, and I can tell you straight: they're built for different problems.

n8n is a no-code/low-code automation platform. You drag nodes, connect them visually, and deploy workflows in minutes. It's HTTP-first, has 400+ integrations baked in, and you don't need to write Python. Perfect for startups, small teams, and anyone who values speed.

Airflow is a data orchestration engine built by Airbnb. It's code-centric, Python-native, and designed for complex DAGs (Directed Acyclic Graphs). You write operators, define task dependencies, and gain granular control. It scales to thousands of jobs per second but requires engineering muscle.

The hard truth: if your workflow fits in 100 nodes and calls 5 APIs, n8n wins on velocity. If you're orchestrating 50 data pipelines with retry logic, monitoring, and multi-environment deployments, Airflow is built for that war.

Let me show you both in action.

n8n for Rapid API Workflows

I'll build a real example: a workflow that pulls GitHub repository stats, enriches them with API data, and saves results to a database. With n8n, this takes 15 minutes.

Step 1: Set Up n8n Cloud or Self-Hosted

If you're using n8n Cloud, sign up and skip to Step 2. If self-hosting, grab a Hetzner VPS with 2GB RAM ($4/month) or Contabo VPS ($3/month). SSH in and run:

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
mkdir n8n && cd n8n

Create a docker-compose.yml:

version: '3.8'
services:
  n8n:
    image: n8nio/n8n
    container_name: n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=your-domain.com
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - WEBHOOK_TUNNEL_URL=https://your-domain.com/
      - DB_TYPE=postgres
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=securepassword123
    depends_on:
      - postgres
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - n8n-network
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    container_name: n8n-postgres
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=securepassword123
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - n8n-network
    restart: unless-stopped

volumes:
  n8n_data:
  postgres_data:

networks:
  n8n-network:
    driver: bridge

Start it:

sudo docker-compose up -d

Access via http://localhost:5678 (or your domain after SSL setup with Nginx).

Step 2: Create the GitHub Stats Workflow

In n8n, create a new workflow:

Trigger: Click the "+" button, add a Webhook node set to POST
GitHub Node: Search "GitHub" in the node library, add it
- Authentication: Select OAuth or add your GitHub token
- Resource: "Repository"
- Operation: "Get"
- Owner: {{ $json.owner }}
- Repository: {{ $json.repo }}
HTTP Request Node: For additional API enrichment
- Method: GET
- URL: https://api.github.com/repos/{{ $json.owner }}/{{ $json.repo }}/traffic/popular
- Headers: Add Authorization: token {{ $env.GITHUB_TOKEN }}
Data Mapper Node: Transform the response
- Map output to name, stars, forks, language
PostgreSQL Node: Store results
- Operation: "Insert"
- Table: github_stats
- Columns: repo_name, stars, forks, language, fetched_at
Send Slack Notification: Add a Slack node (optional)
- Message: Fetched stats for {{ $json.name }} — {{ $json.stars }} stars

Test with a webhook POST:

curl -X POST http://localhost:5678/webhook/github-stats \
  -H "Content-Type: application/json" \
  -d '{"owner":"torvalds","repo":"linux"}'

Response will show 5000+ stars and you've built a real workflow in minutes. No Python, no DAG files.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

Airflow for Complex DAGs

Now let's build the same workflow in Airflow. It's more verbose but gives you industrial-grade control.

Step 1: Install Airflow

On a fresh DigitalOcean droplet (Ubuntu 22.04, 2GB RAM, $6/month):

python3 -m venv airflow-env
source airflow-env/bin/activate
pip install --upgrade pip
pip install apache-airflow==2.8.0
pip install apache-airflow-providers-http
pip install apache-airflow-providers-postgres
pip install apache-airflow-providers-slack
pip install requests

Initialize the database:

export AIRFLOW_HOME=~/airflow
airflow db init
airflow users create --username admin --password admin --firstname Admin --lastname User --role Admin --email admin@example.com

Start the scheduler and webserver:

airflow scheduler &
airflow webserver --port 8080 &

Access at http://localhost:8080.

Step 2: Write the DAG

Create ~/airflow/dags/github_stats_dag.py:

from datetime import datetime, timedelta
from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.operators.http_operator import SimpleHttpOperator
from airflow.providers.postgres.operators.postgres import PostgresOperator
from airflow.providers.slack.operators.slack_webhook import SlackWebhookOperator
from airflow.models import Variable
import requests
import json

default_args = {
    'owner': 'data-team',
    'retries': 2,
    'retry_delay': timedelta(minutes=5),
    'email_on_failure': True,
    'email': ['ops@example.com'],
}

dag = DAG(
    'github_stats_pipeline',
    default_args=default_args,
    description='Fetch GitHub repo stats and store in Postgres',
    schedule_interval='0 */6 * * *',
    start_date=datetime(2024, 1, 1),
    catchup=False,
    tags=['github', 'api', 'analytics'],
)

def fetch_github_data(**context):
    owner = context['dag_run'].conf.get('owner', 'torvalds')
    repo = context['dag_run'].conf.get('repo', 'linux')
    token = Variable.get('GITHUB_TOKEN')

    headers = {'Authorization': f'token {token}'}
    url = f'https://api.github.com/repos/{owner}/{repo}'

    response = requests.get(url, headers=headers, timeout=10)
    response.raise_for_status()

    data = response.json()

    context['task_instance'].xcom_push(
        key='repo_data',
        value={
            'owner': owner,
            'name': data['name'],
            'stars': data['stargazers_count'],
            'forks': data['forks_count'],
            'language': data['language'],
            'description': data['description'],
        }
    )

def enrich_with_traffic(**context):
    task_instance = context['task_instance']
    repo_data = task_instance.xcom_pull(task_ids='fetch_github', key='repo_data')

    owner = repo_data['owner']
    repo = repo_data['name']
    token = Variable.get('GITHUB_TOKEN')

    headers = {'Authorization': f'token {token}'}
    url = f'https://api.github.com/repos/{owner}/{repo}/traffic/popular'

    try:
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()
        traffic = response.json()
        repo_data['top_paths'] = len(traffic) if isinstance(traffic, list) else 0
    except:
        repo_data['top_paths'] = 0

    task_instance.xcom_push(key='enriched_data', value=repo_data)

def prepare_insert_statement(**context):
    task_instance = context['task_instance']
    enriched = task_instance.xcom_pull(task_ids='enrich_traffic', key='enriched_data')

    insert_sql = f"""
    INSERT INTO github_stats (repo_owner, repo_name, stars, forks, language, top_paths, fetched_at)
    VALUES ('{enriched['owner']}', '{enriched['name']}', {enriched['stars']}, {enriched['forks']}, '{enriched['language']}', {enriched['top_paths']}, NOW());
    """

    task_instance.xcom_push(key='insert_sql', value=insert_sql)

fetch_github = PythonOperator(
    task_id='fetch_github',
    python_callable=fetch_github_data,
    dag=dag,
    provide_context=True,
)

enrich_traffic = PythonOperator(
    task_id='enrich_traffic',
    python_callable=enrich_with_traffic,
    dag

Originally published on Automation Insider.

Airflow vs n8n vs Temporal for API workflows

Raizan — Tue, 26 May 2026 08:00:34 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for self-hosting options
Namecheap for custom domain setup
DigitalOcean as an alternative cloud provider
Basic knowledge of REST APIs and webhook concepts
Docker (optional, for containerized deployments)

Why This Comparison Matters
Understanding Airflow, n8n, and Temporal
Architecture & Deployment Models
Building Your First API Workflow
Real-World API Integration Examples
Performance & Scalability Showdown
Cost Analysis & ROI
Getting Started

Why This Comparison Matters

I've built dozens of API workflows over the past five years, and I can tell you that choosing the wrong orchestration tool early costs you thousands in refactoring later. Airflow, n8n, and Temporal each solve the same fundamental problem—executing sequences of API calls reliably—but they approach it from completely different angles.

The stakes are real. You might choose Airflow because it's industry-standard, only to discover you're managing YAML configuration hell. Or you pick n8n for its visual builder and later hit scaling walls that shouldn't exist. Temporal offers rock-solid reliability but requires serious DevOps muscle.

This guide cuts through the noise. I'm comparing these three on what actually matters when you're building production API workflows: setup time, reliability, costs, and the mental overhead of maintenance.

Understanding Airflow, n8n, and Temporal

Let me break down what each tool actually does, not the marketing speak.

Apache Airflow is a task orchestration platform built on Python. It treats workflows as directed acyclic graphs (DAGs) where each node is a task. You define everything in Python code, giving you maximum flexibility but requiring real programming chops.

n8n is a node-based workflow automation platform with a web UI. You drag nodes together, connect them with wire logic, and ship. It's built on Node.js and emphasizes visual workflow design over code. I've used n8n for everything from Slack bots to API data pipelines.

Temporal is a microservices orchestration engine designed for durable execution. It's language-agnostic (runs Go, Python, Java, TypeScript) and built for workflows that can survive infrastructure failures. Think of it as a state machine on steroids.

Each targets a different user persona:

Airflow: Data engineers managing complex ETL pipelines
n8n: No-code users and teams needing fast API integrations
Temporal: Teams building distributed systems where reliability is non-negotiable

Architecture & Deployment Models

Here's where deployment realities force your hand.

Airflow's Architecture

Airflow runs as three core components:

Scheduler – reads DAGs from disk, creates task instances, triggers them
Executor – runs the actual tasks (local, Kubernetes, Celery, etc.)
Web UI – lets you monitor and trigger runs

When you self-host Airflow on a Hetzner VPS or Contabo VPS, you need:

# Install Airflow (Python 3.9+)
pip install apache-airflow==2.7.3

# Initialize the database
airflow db init

# Create a default admin user
airflow users create \
  --username admin \
  --firstname Admin \
  --lastname User \
  --role Admin \
  --email admin@example.com \
  --password airflow

# Start the web server (runs on port 8080)
airflow webserver

# In another terminal, start the scheduler
airflow scheduler

This setup requires a PostgreSQL or MySQL backend (SQLite won't cut it for production). You're managing stateful services, database migrations, and scheduler high availability yourself.

n8n's Architecture

n8n runs as a single Node.js application with a SQLite or PostgreSQL database backing it. One container, one process. When I deploy n8n Cloud, it just works:

# Docker Compose deployment (self-hosted)
version: '3.8'
services:
  n8n:
    image: n8nio/n8n:latest
    environment:
      - DB_TYPE=postgres
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=secure_password_here
      - N8N_HOST=workflow.example.com
      - N8N_PROTOCOL=https
      - NODE_ENV=production
    ports:
      - "5678:5678"
    depends_on:
      - postgres
    volumes:
      - n8n_storage:/home/node/.n8n
    restart: unless-stopped

  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: n8n
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: secure_password_here
    volumes:
      - postgres_storage:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  n8n_storage:
  postgres_storage:

Deploy this to DigitalOcean or a Hetzner VPS, point your domain from Namecheap, and you're live in 20 minutes. The entire workflow state is stored in the database, so you can scale horizontally by spinning up multiple n8n containers behind a load balancer.

Temporal's Architecture

Temporal requires a dedicated cluster. You deploy:

Temporal Server – manages workflow state, task queues, and history
Worker Processes – execute your workflow code
UI – visibility into executions

# Using docker-compose for local Temporal development
version: '3.8'
services:
  temporal:
    image: temporalio/auto-setup:latest
    environment:
      DB: postgres
      DB_PORT: 5432
      POSTGRES_USER: temporal
      POSTGRES_PASSWORD: temporal
      POSTGRES_DB: temporal
    ports:
      - "7233:7233"
      - "6933:6933"
    depends_on:
      - postgres

  temporal-ui:
    image: temporalio/ui:latest
    ports:
      - "8080:8080"
    environment:
      TEMPORAL_ADDRESS: temporal:7233
    depends_on:
      - temporal

  postgres:
    image: postgres:15
    environment:
      POSTGRES_USER: temporal
      POSTGRES_PASSWORD: temporal
      POSTGRES_DB: temporal
    volumes:
      - postgres_temporal:/var/lib/postgresql/data

volumes:
  postgres_temporal:

Temporal is stateful and database-heavy. You need dedicated infrastructure to run it. But once running, it handles workflow durability—if your worker crashes mid-API call, Temporal remembers where you were and retries seamlessly.

Building Your First API Workflow

Let me show you how to build the same workflow in all three tools: fetch data from an API, transform it, and send it to another API.

Airflow Approach

from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.operators.bash import BashOperator
from datetime import datetime, timedelta
import requests
import json

default_args = {
    'owner': 'data_team',
    'retries': 2,
    'retry_delay': timedelta(minutes=5),
    'start_date': datetime(2024, 1, 1),
}

def fetch_user_data(**context):
    """Fetch user data from JSONPlaceholder API"""
    response = requests.get('https://jsonplaceholder.typicode.com/users/1')
    response.raise_for_status()
    user_data = response.json()
    context['task_instance'].xcom_push(key='user_data', value=user_data)
    return user_data

def transform_user_data(**context):
    """Extract and transform relevant fields"""
    user_data = context['task_instance'].xcom_pull(
        task_ids='fetch_user_data',
        key='user_data'
    )
    transformed = {
        'id': user_data['id'],
        'name': user_data['name'],
        'email': user_data['email'],
        'company': user_data['company']['name'],
        'processed_at': datetime.now().isoformat()
    }
    context['task_instance'].xcom_push(
        key='transformed_data',
        value=transformed
    )
    return transformed

def send_to_webhook(**context):
    """Send transformed data to external API"""
    transformed_data = context['task_instance'].xcom_pull(
        task_ids='transform_user_data',
        key='transformed_data'
    )
    webhook_url = 'https://webhook.site/your-unique-id'
    response = requests.post(
        webhook_url,
        json=transformed_data,
        headers={'Content-Type': 'application/json'}
    )
    response.raise_for_status()
    return f"Data sent successfully: {response.status_code}"

dag = DAG(
    'api_workflow_example',
    default_args=default_args,
    description='Fetch, transform, and send API data',
    schedule_interval=timedelta(hours=1),
    catchup=False,
)

task_fetch = PythonOperator(
    task_id='fetch_user_data',
    python_callable=fetch_user_data,
    dag=dag,
)

task_transform = PythonOperator(
    task_id='transform_user_data',
    python_callable=transform_user_data,
    dag=dag,
)

task_send = PythonOperator(
    task_id='send_to_webhook',
    python_callable=send_to_webhook,
    dag=dag,
)

task_fetch >> task_transform >> task_send

This DAG runs hourly, with automatic retries if tasks fail. You manage it via the Airflow UI or CLI. One gotcha: data between tasks flows through XCom (cross-communication), which isn't meant for large payloads. For bigger data, you'd write to S3 or a database.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

n8n Approach

In n8n, you'd build this visually, but here's the JSON configuration export:

{
  "name": "API Data Pipeline",
  "nodes": [
    {
      "parameters": {
        "triggerTimes": {
          "item": [
            {
              "mode": "everyHour"
            }
          ]
        }
      },
      "id": "schedule_trigger",
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.cron",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters":

Originally published on Automation Insider.

Build Custom Webhooks Without Coding Tools

Raizan — Mon, 25 May 2026 08:00:36 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting (optional, for self-hosted)
Namecheap if you need a custom domain
DigitalOcean as an alternative hosting provider

What You'll Need
Understanding Webhooks Without the Code
Setting Up Your First Webhook Receiver
Building Webhook Workflows That React to Data
Transforming and Routing Webhook Payloads
Testing Your Webhooks in Production
Getting Started

Understanding Webhooks Without the Code

I've spent the last three years building automation systems, and here's what I've learned: webhooks are the nervous system of any modern workflow. They're how your apps talk to each other in real-time without polling databases constantly.

Most people think you need to write code to handle webhooks. You don't. Not anymore.

A webhook is just an HTTP request—typically POST or GET—sent from one application to another when something happens. Your Shopify store processes an order, it sends a webhook. Someone fills out your form, it fires a webhook. Your payment processor confirms a transaction, webhook. All of these can trigger downstream actions without touching a single line of code.

The old way required you to spin up a server, write endpoint handlers, manage SSL certificates, and pray your error handling caught edge cases. n8n Cloud flips this entirely. You get a webhook URL instantly, point any service at it, and build logic visually.

When you're comparing automation platforms—and if you're evaluating options, I'd recommend reading about Make vs n8n vs Zapier API integrations 2026—you'll notice n8n gives you the most control over webhook behavior without forcing you into the paid tiers for custom logic.

Setting Up Your First Webhook Receiver

Let me walk you through creating a webhook that listens for incoming data.

Log into n8n Cloud. Click "New" and start a blank workflow.

In the left sidebar, search for the "Webhook" node. Drag it onto your canvas. This is your listening post.

Here's what you'll see in the node settings:

{
  "method": "POST",
  "path": "webhook/my-first-webhook",
  "responseCode": 200,
  "responseData": "success",
  "nodeCredentialType": "httpBasicAuth",
  "authentication": "none"
}

That path becomes part of your unique webhook URL. If your n8n instance lives at https://n8n.chasebot.online, your webhook lands at https://n8n.chasebot.online/webhook/my-first-webhook.

Leave authentication as "none" for now—we'll secure it later. Click the "Webhook" node again and you'll see a blue button that says "Execute Webhook". Click it, and n8n generates a unique, testable URL.

Now add a second node: search for "Set" in the left sidebar. Connect the Webhook node to Set by dragging the output dot. In the Set node, you're going to map the incoming webhook data to fields you want to use downstream.

The webhook payload arrives as $json in n8n. Here's what that configuration looks like:

{
  "assignments": [
    {
      "name": "incoming_email",
      "value": "{{ $json.body.email }}",
      "type": "string"
    },
    {
      "name": "incoming_name",
      "value": "{{ $json.body.name }}",
      "type": "string"
    },
    {
      "name": "incoming_timestamp",
      "value": "{{ $json.headers['x-timestamp'] }}",
      "type": "string"
    }
  ]
}

The dollar-sign syntax is n8n's expression language. $json.body.email pulls the email field from whatever JSON was sent to your webhook. $json.headers grabs HTTP headers.

Now test it. In n8n Cloud, click the blue "Execute Webhook" button and copy the URL. Open a new browser tab and use an online webhook testing tool (RequestBin, Webhook.cool, or even curl from your terminal):

curl -X POST https://webhook.n8n.cloud/[YOUR-UNIQUE-URL] \
  -H "Content-Type: application/json" \
  -d '{"name":"Sarah Chen","email":"sarah@example.com"}'

Watch your n8n workflow execute. You'll see the data flow through the Webhook node, then the Set node transforms it. That's it. No server. No code. No DevOps nightmare.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

Building Webhook Workflows That React to Data

Now that you have incoming data, let's do something with it.

I'm going to show you a real workflow: receiving a webhook from a form submission, then triggering different actions based on what's in the payload.

Start fresh. Add a Webhook node. This time, in the node settings, click "Add Field" under "Request Body Schema". Manually define the shape of data you expect:

{
  "type": "object",
  "properties": {
    "email": {
      "type": "string",
      "description": "User email address"
    },
    "product_id": {
      "type": "string",
      "description": "Which product was clicked"
    },
    "source": {
      "type": "string",
      "enum": ["web", "mobile", "api"],
      "description": "Where the request came from"
    }
  },
  "required": ["email", "product_id"]
}

This schema validates incoming webhooks. If someone sends a webhook without email and product_id, n8n rejects it with a 400 error and logs the mismatch. This saves you from garbage data tanking your downstream workflow.

Next, add a conditional node. Search for "If" in the left sidebar. Connect the Webhook output to it.

In the If node, set up a condition:

{
  "conditions": [
    {
      "value1": "{{ $json.source }}",
      "operation": "equals",
      "value2": "mobile"
    }
  ],
  "combineOperation": "any"
}

This branches your workflow: if the source is "mobile", take the true branch; otherwise, take the false branch.

From the true branch, add a node that sends a Slack message (search for "Slack" in the node library and authenticate with your workspace). Connect it to the true output of your If node:

{
  "channel": "#sales-alerts",
  "text": "📱 Mobile signup from {{ $json.email }} – Product: {{ $json.product_id }}",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Mobile Conversion Alert*\nEmail: {{ $json.email }}\nProduct ID: {{ $json.product_id }}"
      }
    }
  ]
}

From the false branch, add a different Slack message (or any other action—email, database write, webhook forward, etc.).

Deploy this workflow. Now whenever anyone submits a form or triggers an external webhook pointing to your n8n instance, it automatically routes notifications based on the source. Mobile users get flagged in a specific channel. Web users go elsewhere.

This scales to dozens of branches. The visual canvas lets you see the entire logic at once, which beats digging through code files any day.

Transforming and Routing Webhook Payloads

Here's where things get powerful. Many webhooks arrive in messy formats. Your Stripe webhook looks different from your Shopify webhook. Your custom app payload doesn't match your form plugin's structure.

You need to normalize them.

Add a "Function" node (search for it in the node library). This is JavaScript you can write without leaving the visual interface. Don't worry—it's sandboxed and forgiving.

Here's a practical example: you're receiving webhooks from multiple sources, and you want to standardize all of them into a single format before storing them in a database:

const sourceType = $json.source_system || 'unknown';
const timestamp = new Date().toISOString();

let standardizedPayload = {
  id: generateId(),
  source: sourceType,
  receivedAt: timestamp,
  data: {}
};

if (sourceType === 'shopify') {
  standardizedPayload.data = {
    customerId: $json.customer_id,
    orderId: $json.order_id,
    total: $json.total_price,
    email: $json.customer_email,
    createdAt: $json.created_at
  };
} else if (sourceType === 'stripe') {
  standardizedPayload.data = {
    customerId: $json.customer,
    orderId: $json.id,
    total: $json.amount / 100,
    email: $json.metadata?.email || null,
    createdAt: new Date($json.created * 1000).toISOString()
  };
} else if (sourceType === 'custom_form') {
  standardizedPayload.data = {
    customerId: $json.user_id,
    orderId: $json.submission_id,
    total: parseFloat($json.price) || 0,
    email: $json.email_address,
    createdAt: $json.timestamp
  };
}

function generateId() {
  return 'evt_' + Math.random().toString(36).substr(2, 9);
}

return standardizedPayload;

After this Function node runs, every webhook—whether it came from Shopify, Stripe, or your custom form—exits with the same structure:

{
  "id": "evt_a1b2c3d4e",
  "source": "shopify",
  "receivedAt": "2024-01-15T14:32:00.000Z",
  "data": {
    "customerId": "cust_12345",
    "orderId": "order_67890",
    "total": 99.99,
    "email": "user@example.com",
    "createdAt": "2024-01-15T14:31:00.000Z"
  }
}

Now you can connect this to a single database write, a single API call, or a single downstream workflow—no branching logic needed. One format in, one action out.

This is where the power emerges. If you're running multiple systems on limited resources—and if you're interested in optimization, I wrote about How I Run 3 Automated Systems on a Single $7/Month VPS—normalizing payloads at the webhook layer saves you compute cycles throughout your entire architecture.

Testing Your Webhooks in Production

You can't debug what you can't see. Before pushing a webhook workflow live, you need visibility.

n8n Cloud has built-in execution history. Every time a webhook fires, n8n logs the input, the transformations, and the output. Click on any execution and drill into each node to see exactly what data passed through.

For manual testing before going live, use the "Execute Webhook"

Originally published on Automation Insider.

Best n8n Alternatives for API-First Developers 2026

Raizan — Sun, 24 May 2026 08:00:42 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for hosting alternatives
DigitalOcean as a managed infrastructure option
API credentials for at least one service (GitHub, Stripe, Slack, etc.)
Node.js 16+ or Docker installed locally (optional, for testing)
A code editor like VS Code

Why Developers Are Moving Beyond n8n
The API-First Workflow Automation Landscape
Top n8n Alternatives for API-Driven Teams
Building Your First Workflow: n8n vs. Zapier vs. Temporal
Hosting & Infrastructure Decisions
Getting Started with Your Choice

Why Developers Are Moving Beyond n8n

I've been in the workflow automation space for years, and I'm seeing a real shift in 2026. n8n is solid—open-source, self-hosted, powerful integrations—but it's not always the right fit for every team. Some developers need stronger database support. Others want native async/await patterns. A few want orchestration at the enterprise level without the overhead.

The landscape has matured. We're not just talking about "no-code" tools anymore. Modern API-first developers need platforms that speak their language: REST hooks, webhooks, GraphQL, serverless functions, and event-driven architecture.

I'm going to walk you through the real contenders, show you working code, and help you pick the right tool for your specific use case.

The API-First Workflow Automation Landscape

Before we compare alternatives, let me clarify what "API-first" actually means in this context. You're looking for platforms that:

Expose their own APIs – You can trigger workflows programmatically, not just through UI clicks
Handle async operations natively – No artificial delays or polling nightmares
Support webhooks bidirectionally – Receive and send without gymnastics
Work well with databases – When you need SQLite vs PostgreSQL for Small Projects: When to Use Which, the tool shouldn't force one approach
Scale with your codebase – From a single Lambda function to multi-region deployments

n8n ticks most of these boxes, but the alternatives I'm about to show you each solve specific pain points.

Top n8n Alternatives for API-Driven Teams

1. Temporal: Workflow Orchestration for Serious Infrastructure

Temporal is a durable workflow engine that's absolutely crushing it for infrastructure teams. Unlike n8n, which is GUI-first, Temporal is code-first. You write workflows in TypeScript, Python, or Go, and Temporal handles the orchestration, retries, timeouts, and state management.

When to choose Temporal:

You're running microservices and need workflow reliability
Your team writes code every day (this is your language, not a visual tool)
You need guaranteed execution, not best-effort automation
Scaling to millions of workflow runs annually

When to skip it:

You need quick, simple integrations (overkill)
Your team doesn't code
You want managed infrastructure without Docker/Kubernetes

Here's a real Temporal workflow that processes API requests with retry logic:

import { 
  proxyActivities, 
  retry, 
  ActivityFailureError,
  ApplicationFailure
} from '@temporalio/workflow';
import * as wf from '@temporalio/workflow';

interface PaymentRequest {
  userId: string;
  amount: number;
  currency: string;
  idempotencyKey: string;
}

interface PaymentResult {
  transactionId: string;
  status: 'completed' | 'failed' | 'pending';
  timestamp: string;
}

const activities = proxyActivities<typeof import('./activities')>({
  startToCloseTimeout: '1 minute',
  retry: {
    initialInterval: '1 second',
    maximumInterval: '1 minute',
    maximumAttempts: 5,
    backoffCoefficient: 2.0,
    nonRetryableErrorTypes: ['InvalidPaymentError', 'FraudDetected']
  }
});

export async function paymentWorkflow(
  request: PaymentRequest
): Promise<PaymentResult> {
  let result: PaymentResult;

  try {
    result = await activities.processPaymentWithStripe(request);
  } catch (err) {
    if (err instanceof ApplicationFailure) {
      if (err.type === 'FraudDetected') {
        result = {
          transactionId: '',
          status: 'failed',
          timestamp: new Date().toISOString()
        };
      } else {
        throw err;
      }
    } else {
      throw err;
    }
  }

  if (result.status === 'completed') {
    await activities.sendConfirmationEmail(request.userId, result);
  }

  return result;
}

And the activity implementation (the actual work):

import axios from 'axios';
import nodemailer from 'nodemailer';

interface PaymentRequest {
  userId: string;
  amount: number;
  currency: string;
  idempotencyKey: string;
}

interface PaymentResult {
  transactionId: string;
  status: 'completed' | 'failed' | 'pending';
  timestamp: string;
}

const stripeApiKey = process.env.STRIPE_API_KEY!;
const emailTransporter = nodemailer.createTransport({
  host: process.env.SMTP_HOST,
  port: parseInt(process.env.SMTP_PORT || '587'),
  auth: {
    user: process.env.SMTP_USER,
    pass: process.env.SMTP_PASS
  }
});

export async function processPaymentWithStripe(
  request: PaymentRequest
): Promise<PaymentResult> {
  const stripeUrl = 'https://api.stripe.com/v1/payment_intents';

  const formData = new URLSearchParams();
  formData.append('amount', String(Math.round(request.amount * 100)));
  formData.append('currency', request.currency.toLowerCase());
  formData.append('idempotency_key', request.idempotencyKey);
  formData.append('description', `Payment for user ${request.userId}`);
  formData.append('automatic_payment_methods[enabled]', 'true');

  const response = await axios.post(stripeUrl, formData, {
    headers: {
      Authorization: `Bearer ${stripeApiKey}`,
      'Content-Type': 'application/x-www-form-urlencoded'
    }
  });

  const stripeStatus = response.data.status;
  let workflowStatus: 'completed' | 'failed' | 'pending' = 'pending';

  if (stripeStatus === 'succeeded') {
    workflowStatus = 'completed';
  } else if (stripeStatus === 'requires_action') {
    workflowStatus = 'pending';
  } else {
    workflowStatus = 'failed';
  }

  return {
    transactionId: response.data.id,
    status: workflowStatus,
    timestamp: new Date().toISOString()
  };
}

export async function sendConfirmationEmail(
  userId: string,
  result: PaymentResult
): Promise<void> {
  await emailTransporter.sendMail({
    from: 'payments@example.com',
    to: `user_${userId}@example.com`,
    subject: 'Payment Confirmation',
    html: `<p>Your payment ${result.transactionId} has been ${result.status}.</p>`
  });
}

This approach gives you full control and observability. Temporal keeps a complete history of every workflow execution, so debugging is transparent.

2. Make.com: The Visual Powerhouse with Deep Integration

Make.com (formerly Integromat) is honestly the closest competitor to n8n for visual workflow building, but it's positioned more as a platform with enterprise features. Where n8n emphasizes self-hosting and open-source, Make emphasizes integrations and managed infrastructure.

Key differences from n8n:

1,000+ pre-built integrations (vs. n8n's 400+)
Scenario execution is slightly faster (optimized infrastructure)
Pricing based on operations, not self-hosting (higher long-term cost if scaling)
Their API is more mature for custom triggers

If you're building Stripe webhooks into HubSpot CRM workflows, Make.com's integration marketplace is genuinely better. But if you need to self-host and customize deeply, n8n wins.

3. Zapier with Custom Actions & API Tools

Zapier isn't "API-first" in the code sense—it's user-friendly first. But for teams that want to delegate workflow management to non-technical staff while maintaining control, Zapier's custom code actions (available on Pro tier and up) are underrated.

You write JavaScript directly in Zapier:

const fetch = require('node-fetch');

async function processWebhookData(zapierData) {
  const stripeApiKey = process.env.stripe_api_key;

  const payload = {
    email: zapierData.email,
    first_name: zapierData.first_name,
    last_name: zapierData.last_name,
    metadata: {
      source: 'zapier_webhook',
      timestamp: new Date().toISOString()
    }
  };

  const response = await fetch('https://api.stripe.com/v1/customers', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${stripeApiKey}`,
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: new URLSearchParams(payload).toString()
  });

  const result = await response.json();

  if (!response.ok) {
    throw new Error(`Stripe API error: ${result.error.message}`);
  }

  return {
    customer_id: result.id,
    created: result.created,
    success: true
  };
}

return processWebhookData(inputData);

When Zapier wins:

You want someone non-technical to manage workflows
Integration breadth matters more than customization
You don't mind monthly operational costs
Your workflows are relatively simple

4. Deno Deploy + Fresh: Serverless API Automation

Here's my take: serverless platforms like Deno Deploy, Cloudflare Workers, or AWS Lambda aren't traditional "workflow" tools, but for API-first developers, they're the most natural fit. You write functions, deploy them instantly, and they scale to zero cost when idle.

For handling webhooks and orchestrating APIs, this is increasingly the pattern I see in 2026:

import { serve } from "https://deno.land/std@0.208.0/http/server.ts";

interface WebhookPayload {
  event: string;
  data: {
    customer_id: string;
    amount: number;
    currency: string;
  };
  timestamp: string;
}

interface WorkflowState {
  stripeChargeId: string;
  emailSent: boolean;
  slackNotified: boolean;
}

async function chargeCustomer(customerId: string, amount: number, currency: string): Promise<string> {
  const stripeApiKey = Deno.env.get('STRIPE_SECRET_KEY')!;

  const chargeParams = new URLSearchParams({

Originally published on Automation Insider.

Airflow vs n8n for API-driven data pipelines

Raizan — Sat, 23 May 2026 08:00:25 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for hosting (if self-hosting)
DigitalOcean as an alternative hosting option
Python 3.8+ (for Airflow)
PostgreSQL or MySQL database
Basic understanding of REST APIs and workflow automation concepts

Understanding Airflow and n8n
Architecture and Deployment Models
Building Your First API-Driven Pipeline
Scalability, Performance, and Real-World Considerations
Which One Should You Actually Choose?
Getting Started

Understanding Airflow and n8n

I've spent the last few years building data pipelines, and the Airflow vs n8n question keeps coming up. Both tools solve the same fundamental problem—orchestrating tasks and workflows—but they approach it from completely different angles.

Apache Airflow is a workflow orchestration platform built by Airbnb, now an Apache project. It's written in Python, code-first, and treats workflows as directed acyclic graphs (DAGs). Think of it as a framework for engineers who want maximum control and don't mind writing Python code to define their pipelines.

n8n, on the other hand, is a visual workflow automation platform that's been gaining serious traction. It's node-based, has a browser-friendly UI, and integrates with hundreds of APIs out of the box. You can build complex workflows without touching code, though it supports code nodes when you need them.

For API-driven data pipelines specifically, this distinction matters. A lot.

Architecture and Deployment Models

Here's where the philosophies diverge.

Airflow's Architecture:

Airflow uses a distributed architecture with a scheduler, executor, and metadata database. The scheduler reads your DAGs and decides what to execute. Executors actually run the tasks—you can use the LocalExecutor for development, CeleryExecutor for distributed task queues, or KubernetesExecutor for container-based scaling.

This complexity gives you power. You get fine-grained control over task dependencies, retries, backoffs, and custom operators. But it also means you're responsible for maintaining multiple components.

n8n's Architecture:

n8n runs as a single application (though it supports clustering). It uses a database to store workflow definitions and execution history. There's no separate scheduler/executor split—the application handles orchestration internally. When you deploy n8n Cloud, you're getting fully managed infrastructure. If you self-host on Hetzner VPS or DigitalOcean, it's a single Docker container or Node.js process.

For API-driven pipelines, this matters. n8n's simplicity means you can have a workflow hitting 50 different APIs up and running in an afternoon. Airflow would take longer to set up, but it'd handle 50,000 API calls across thousands of tasks more elegantly at scale.

Building Your First API-Driven Pipeline

Let me show you how both tools handle a common scenario: fetch data from an API, transform it, and save it to a database.

Airflow Approach

In Airflow, you define a DAG in Python:

from datetime import datetime, timedelta
from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.operators.bash import BashOperator
import requests
import json
import psycopg2
from psycopg2.extras import execute_values

default_args = {
    'owner': 'data_team',
    'retries': 2,
    'retry_delay': timedelta(minutes=5),
    'start_date': datetime(2024, 1, 1),
}

dag = DAG(
    'fetch_user_data_pipeline',
    default_args=default_args,
    description='Fetch user data from API and store in PostgreSQL',
    schedule_interval='0 */6 * * *',
    catchup=False,
)

def fetch_from_api():
    url = 'https://jsonplaceholder.typicode.com/users'
    try:
        response = requests.get(url, timeout=30)
        response.raise_for_status()
        data = response.json()
        with open('/tmp/user_data.json', 'w') as f:
            json.dump(data, f)
        print(f"Successfully fetched {len(data)} users")
        return len(data)
    except requests.exceptions.RequestException as e:
        print(f"API request failed: {e}")
        raise

def transform_and_validate(ti):
    with open('/tmp/user_data.json', 'r') as f:
        users = json.load(f)

    validated_users = []
    for user in users:
        if all(key in user for key in ['id', 'name', 'email', 'phone']):
            validated_users.append({
                'user_id': user['id'],
                'name': user['name'],
                'email': user['email'],
                'phone': user['phone'],
                'company': user.get('company', {}).get('name', 'Unknown'),
                'fetched_at': datetime.now().isoformat()
            })

    with open('/tmp/validated_users.json', 'w') as f:
        json.dump(validated_users, f)
    print(f"Validated {len(validated_users)} out of {len(users)} users")
    return len(validated_users)

def load_to_database(ti):
    try:
        conn = psycopg2.connect(
            host='localhost',
            database='pipeline_db',
            user='pipeline_user',
            password='secure_password',
            port=5432
        )
        cursor = conn.cursor()

        with open('/tmp/validated_users.json', 'r') as f:
            users = json.load(f)

        insert_query = """
        INSERT INTO users (user_id, name, email, phone, company, fetched_at)
        VALUES %s
        ON CONFLICT (user_id) DO UPDATE SET
            name = EXCLUDED.name,
            email = EXCLUDED.email,
            phone = EXCLUDED.phone,
            company = EXCLUDED.company,
            fetched_at = EXCLUDED.fetched_at
        """

        values = [
            (u['user_id'], u['name'], u['email'], u['phone'], u['company'], u['fetched_at'])
            for u in users
        ]

        execute_values(cursor, insert_query, values)
        conn.commit()
        cursor.close()
        conn.close()
        print(f"Loaded {len(users)} users into database")
        return len(users)
    except psycopg2.Error as e:
        print(f"Database error: {e}")
        raise

task_fetch = PythonOperator(
    task_id='fetch_api_data',
    python_callable=fetch_from_api,
    dag=dag,
)

task_transform = PythonOperator(
    task_id='transform_data',
    python_callable=transform_and_validate,
    dag=dag,
)

task_load = PythonOperator(
    task_id='load_to_postgres',
    python_callable=load_to_database,
    dag=dag,
)

task_cleanup = BashOperator(
    task_id='cleanup_temp_files',
    bash_command='rm -f /tmp/user_data.json /tmp/validated_users.json',
    dag=dag,
)

task_fetch >> task_transform >> task_load >> task_cleanup

This DAG runs every 6 hours, fetches user data from an API, validates it, loads it into PostgreSQL, and cleans up temporary files. If any task fails, Airflow retries it twice with 5-minute delays.

n8n Approach

With n8n, you'd build the same workflow visually, but here's how you'd export and manage it via JSON (which is what n8n stores internally):

{
  "name": "Fetch User Data Pipeline",
  "nodes": [
    {
      "parameters": {
        "triggerType": "interval",
        "unit": "hours",
        "value": 6
      },
      "id": "schedule-trigger",
      "name": "Schedule",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "url": "https://jsonplaceholder.typicode.com/users",
        "method": "GET",
        "authentication": "none",
        "responseFormat": "json"
      },
      "id": "http-request-api",
      "name": "Fetch User API",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [450, 300]
    },
    {
      "parameters": {
        "functionCode": "return items.map(item => {\n  const user = item.json;\n  if (!user.id || !user.name || !user.email || !user.phone) {\n    return null;\n  }\n  return {\n    json: {\n      user_id: user.id,\n      name: user.name,\n      email: user.email,\n      phone: user.phone,\n      company: user.company?.name || 'Unknown',\n      fetched_at: new Date().toISOString()\n    }\n  };\n}).filter(item => item !== null);"
      },
      "id": "code-transform",
      "name": "Transform & Validate",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [650, 300]
    },
    {
      "parameters": {
        "host": "localhost",
        "port": 5432,
        "database": "pipeline_db",
        "user": "pipeline_user",
        "password": "secure_password",
        "ssl": false,
        "query": "INSERT INTO users (user_id, name, email, phone, company, fetched_at) VALUES (@user_id, @name, @email, @phone, @company, @fetched_at) ON CONFLICT (user_id) DO UPDATE SET name=EXCLUDED.name, email=EXCLUDED.email, phone=EXCLUDED.phone, company=EXCLUDED.company, fetched_at=EXCLUDED.fetched_at"
      },
      "id": "postgres-insert",
      "name": "Load to PostgreSQL",
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2,
      "position": [850, 300]
    }
  ],
  "connections": {
    "schedule-trigger": {
      "main": [[{ "node": "http-request-api", "type": "main", "index": 0 }]]
    },
    "http-request-api": {
      "main": [[{ "node": "code-transform", "type": "main", "index": 0 }]]
    },
    "code-transform": {
      "main": [[{ "node": "postgres-insert", "type": "main", "index": 0 }]]
    }
  },
  "settings": {
    "saveDataErrorExecution": "all",
    "save

Originally published on Automation Insider.

Temporal vs n8n vs Airflow for Data Pipelines

Raizan — Thu, 21 May 2026 08:00:41 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting
DigitalOcean as alternative
Python 3.8+ (for Airflow and Temporal)
Docker and Docker Compose
Git for version control

What You'll Need
The Big Picture: Why This Matters
Temporal: The Enterprise-Grade Workflow Engine
n8n: The Visual Automation Platform
Apache Airflow: The Python-Native Orchestrator
Head-to-Head Comparison
Getting Started with Your First Pipeline
Choosing the Right Tool for Your Use Case

The Big Picture: Why This Matters

I've built data pipelines for everything from real-time market data ingestion to batch processing infrastructure. The question I get asked most isn't "which tool is best?" but rather "which tool is best for what I'm trying to do?" These three platforms—Temporal, n8n, and Apache Airflow—solve workflow automation problems, but they approach it from completely different angles.

The choice you make affects deployment complexity, team learning curve, scalability, and your operational overhead. Get it wrong, and you're either over-engineering a simple automation or struggling with a tool that wasn't designed for your scale.

Temporal: The Enterprise-Grade Workflow Engine

Temporal is built for distributed systems that need bulletproof reliability and auditing. It's what you reach for when "the job must complete, no matter what," and you need a complete execution history for compliance.

How Temporal Works:

Temporal separates your business logic (Workflows) from the execution engine. You write code in TypeScript, Go, Python, or Java, and Temporal handles retries, timeouts, and failure recovery automatically. It's built on a novel idea: every decision in your workflow is deterministic and replayed through the same code path.

Here's a minimal TypeScript workflow that processes orders with built-in failure handling:

import { proxyActivities, defineSignal, defineQuery, setHandler } from '@temporalio/workflow';
import type * as activities from './activities';

const { processPayment, notifyUser, logOrder } = proxyActivities<typeof activities>({
  startToCloseTimeout: '5 minutes',
});

export interface OrderInput {
  orderId: string;
  amount: number;
  email: string;
  retryCount: number;
}

export async function orderProcessingWorkflow(input: OrderInput) {
  let attempts = 0;
  const maxRetries = 3;

  while (attempts < maxRetries) {
    try {
      const paymentResult = await processPayment({
        orderId: input.orderId,
        amount: input.amount,
      });

      if (paymentResult.success) {
        await logOrder({
          orderId: input.orderId,
          status: 'completed',
          paidAmount: input.amount,
        });

        await notifyUser({
          email: input.email,
          message: `Your order ${input.orderId} has been processed successfully`,
        });

        return { status: 'success', orderId: input.orderId };
      }
    } catch (error) {
      attempts++;
      if (attempts >= maxRetries) {
        await notifyUser({
          email: input.email,
          message: `Order ${input.orderId} failed after ${maxRetries} attempts`,
        });
        throw new Error(`Payment processing failed for order ${input.orderId}`);
      }
    }
  }
}

And the corresponding activities (the actual work):

export async function processPayment(params: {
  orderId: string;
  amount: number;
}): Promise<{ success: boolean; transactionId: string }> {
  const response = await fetch('https://api.payment-provider.com/charge', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${process.env.PAYMENT_API_KEY}` },
    body: JSON.stringify({
      orderId: params.orderId,
      amount: params.amount,
      currency: 'USD',
    }),
  });

  if (!response.ok) {
    throw new Error(`Payment API returned ${response.status}`);
  }

  const data = await response.json();
  return { success: true, transactionId: data.transaction_id };
}

export async function logOrder(params: {
  orderId: string;
  status: string;
  paidAmount: number;
}): Promise<void> {
  await fetch('https://your-api.com/orders/log', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(params),
  });
}

export async function notifyUser(params: {
  email: string;
  message: string;
}): Promise<void> {
  await fetch('https://your-api.com/notify', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(params),
  });
}

When Temporal Shines:

Long-running processes (anything that takes hours or days)
Distributed transactions requiring exact-once semantics
Complex state machines with strict audit requirements
Financial systems, order processing, payment reconciliation

The Tradeoff:

Temporal requires operational expertise. You're running a database (either Cassandra or PostgreSQL), worker services, and the server itself. It's not a SaaS product you spin up in five minutes.

n8n: The Visual Automation Platform

n8n is the opposite of Temporal. It's designed for people who want to see their workflows and click together integrations without writing code.

Using n8n Cloud, I can build data pipelines by connecting nodes. Here's what a typical data enrichment workflow looks like:

{
  "nodes": [
    {
      "parameters": {
        "url": "https://api.example.com/users",
        "authentication": "oAuth2",
        "requestMethod": "GET",
        "options": {}
      },
      "name": "Fetch Users",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "mode": "runOnceForAllItems",
        "expression": "={\n  \"id\": $json.user_id,\n  \"email\": $json.email,\n  \"processed_at\": $now.toIso()\n}"
      },
      "name": "Transform Data",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.2,
      "position": [500, 300],
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://your-database.com/insert",
        "authentication": "basicAuth",
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {
              "name": "data",
              "value": "={{ $json }}"
            }
          ]
        }
      },
      "name": "Save to Database",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.1,
      "position": [750, 300]
    }
  ],
  "connections": {
    "Fetch Users": {
      "main": [
        [
          {
            "node": "Transform Data",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Transform Data": {
      "main": [
        [
          {
            "node": "Save to Database",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

This three-node workflow:

Fetches users from an API
Transforms each record to include metadata
Saves them to your database

You can host n8n on your own infrastructure for full control. Here's a Docker Compose setup:

version: '3.8'
services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=change_me_securely
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - NODE_ENV=production
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=n8n_db_password
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    container_name: n8n_postgres
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=n8n_db_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  n8n_data:
  postgres_data:

Deploy this on Hetzner VPS or DigitalOcean, and you have a production n8n instance. For more details on the self-hosted vs cloud debate, check out my guide on self-hosted workflow automation vs cloud SaaS platforms.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

When n8n Wins:

Quick integrations between SaaS tools
Visual workflow design for non-technical users
Rapid prototyping and testing
Small to medium-scale data operations
Teams that need ease-of-use over raw power

The Tradeoff:

While n8n is flexible, it's not ideal for complex business logic that requires significant code. You can write custom code in nodes, but you're fighting the platform's paradigm if you need heavy computation.

Apache Airflow: The Python-Native Orchestrator

Airflow lets you define workflows as Python DAGs (Directed Acyclic Graphs). If you're comfortable with Python and need fine-grained control, Airflow is your platform.

Here's a data pipeline that downloads crypto price data, processes it, and uploads results:

from datetime import datetime, timedelta
from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.operators.bash import BashOperator
from airflow

Originally published on Automation Insider.

DEV Community: Raizan

Temporal vs Make vs Zapier for API automation

What You'll Need

Table of Contents

The Core Differences

Temporal: The Enterprise Orchestrator

Setting Up Temporal Locally

Make: The Visual Mid-Market Solution

Building an API Orchestration Workflow in Make

Zapier: The No-Code Leader

Building a Simple Zapier Zap

Building Your First API Automation

Using n8n (The Practical Middle Ground)

Zapier vs n8n vs Make: Enterprise Automation Costs

What You'll Need

Table of Contents

The Real Cost Breakdown

Zapier's Pricing Model and Hidden Costs

n8n's Self-Hosted vs Cloud Strategy

Make.com's Deceptive Task Counting

Running the Numbers: A Real-World Scenario

When to Use Each Platform

Getting Started

Temporal vs n8n vs Zapier API Automation Costs

What You'll Need

Table of Contents

Understanding the Three Platforms

Temporal: The Enterprise Choice

n8n: The Flexible Middle Ground

Zapier: The Simple Starter

Direct Cost Comparison Framework

Building Your Own Cost Calculator

Budibase vs n8n vs Retool for API workflows

What You'll Need

Table of Contents

The Core Difference

n8n for Power Users

Why n8n dominates for APIs:

Budibase for Full-Stack Speed

Retool for Internal Tools

Comparing API Workflow Capabilities

Airbyte vs n8n vs Fivetran: ETL Pipelines

What You'll Need

Table of Contents

The Core Differences

Airbyte Deep Dive

n8n for ETL Workflows

Fivetran's Enterprise Approach

Temporal vs n8n vs Airflow Batch Processing

What You'll Need

Table of Contents

Why Batch Processing Matters

Understanding Temporal, n8n, and Airflow

Temporal for Distributed Batch Jobs

n8n's Approach to Batch Processing

n8n vs Airflow for API workflow automation

What You'll Need

Table of Contents

The Core Difference: When to Pick Each

n8n for Rapid API Workflows

Step 1: Set Up n8n Cloud or Self-Hosted

Step 2: Create the GitHub Stats Workflow

Airflow for Complex DAGs

Step 1: Install Airflow

Step 2: Write the DAG

Airflow vs n8n vs Temporal for API workflows

What You'll Need

Table of Contents

Why This Comparison Matters

Understanding Airflow, n8n, and Temporal

Architecture & Deployment Models

Airflow's Architecture

n8n's Architecture

Temporal's Architecture

Building Your First API Workflow

Airflow Approach

n8n Approach

Build Custom Webhooks Without Coding Tools

What You'll Need

Table of Contents