DEV Community: Raizan

Temporal vs Make for API-First Workflows

Raizan — Wed, 20 May 2026 16:02:59 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for hosting Temporal locally
DigitalOcean as an alternative for cloud deployment
Namecheap if you need a domain
API keys for your target services (Stripe, GitHub, Slack, etc.)
Docker and Docker Compose (free, open-source)
Node.js 18+ and npm

What's the Real Difference Between Temporal and Make?
Temporal: The Orchestration Engine Approach
Make: The Visual No-Code Platform
Building Your First Temporal Workflow
Building the Same Workflow in Make
Cost and Infrastructure Breakdown
Getting Started

What's the Real Difference Between Temporal and Make?

I've spent the last three years building API-first workflows for SaaS companies, and this question comes up constantly. The short answer? Temporal and Make.com solve the same business problem—automating API calls across services—but they approach it like night and day.

Temporal is a workflow orchestration platform. It's open-source, runs on your infrastructure, and treats workflows like distributed systems. You write code. You version control it. You deploy it like a regular application.

Make is a visual, cloud-hosted workflow builder. You drag and drop modules, connect APIs with a GUI, and hit publish. No code required.

The choice between them depends on your tolerance for infrastructure complexity, your budget constraints, and whether you want the flexibility of code or the simplicity of no-code. I've helped teams switch from expensive SaaS solutions like Zapier to self-hosted alternatives to reduce their SaaS bill, and this comparison is foundational to that conversation.

If you're building workflows that require complex branching logic, error handling, retry strategies, or need to integrate deeply with your existing codebase, Temporal wins. If you want to ship something in hours without touching a terminal, Make is faster. Let me show you how both work in practice.

Temporal: The Orchestration Engine Approach

Temporal was created by engineers from Uber and Doordash who needed a system that could handle reliability at scale. It's not a SaaS platform—it's a framework. You run the Temporal server yourself, write workflows in TypeScript or Python, and execute them against that server.

Here's why developers love it:

Automatic retries and error handling – If an API call fails, Temporal retries it with exponential backoff without you writing retry logic.

Durable execution – If your worker crashes mid-workflow, Temporal replays it from the last checkpoint. No data loss.

Visibility – You get a full history of every workflow execution with timestamps, inputs, outputs, and failures.

Cost efficiency – No per-execution fees. You pay only for the infrastructure running your server.

This is especially important if you're handling high-volume workflows. Imagine running 10,000 API calls per day through Zapier. You'd hit their usage limits fast. With Temporal, those 10,000 calls cost you only the server resources needed to run them.

Setting Up Temporal Locally

Let's get a Temporal server running on your Hetzner VPS or local Docker setup.

mkdir temporal-workflow && cd temporal-workflow
curl -O https://raw.githubusercontent.com/temporalio/docker-compose/main/docker-compose.yml
docker-compose up -d

Once the server is running on localhost:7233, create a package.json:

{
  "name": "temporal-api-workflow",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "worker": "ts-node src/worker.ts",
    "workflow": "ts-node src/run-workflow.ts"
  },
  "dependencies": {
    "@temporalio/client": "^1.11.0",
    "@temporalio/worker": "^1.11.0",
    "@temporalio/workflow": "^1.11.0",
    "axios": "^1.6.0",
    "ts-node": "^10.9.0",
    "typescript": "^5.0.0"
  }
}

Install dependencies:

npm install

Now create your workflow definition in src/workflows.ts:

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

const { fetchUserFromStripe, sendSlackNotification, logToDatabase } = proxyActivities<typeof activities>({
  startToCloseTimeout: '10 seconds',
  retry: {
    initialInterval: '1 second',
    maximumInterval: '1 minute',
    maximumAttempts: 5,
  },
});

export async function processStripeWebhook(customerId: string) {
  const user = await fetchUserFromStripe(customerId);

  if (user.status === 'active') {
    await sendSlackNotification({
      channel: '#billing',
      message: `User ${user.email} is active and has ${user.subscriptions.length} subscriptions`,
    });
  }

  const logResult = await logToDatabase({
    customerId,
    status: user.status,
    timestamp: new Date().toISOString(),
  });

  return {
    processedAt: new Date(),
    userId: user.id,
    notificationSent: user.status === 'active',
    logId: logResult.id,
  };
}

Now define the activities that do the actual work in src/activities.ts:

import axios from 'axios';

interface StripeUser {
  id: string;
  email: string;
  status: string;
  subscriptions: Array<{ id: string; status: string }>;
}

interface SlackPayload {
  channel: string;
  message: string;
}

interface DatabaseLog {
  customerId: string;
  status: string;
  timestamp: string;
}

interface LogResult {
  id: string;
}

export async function fetchUserFromStripe(customerId: string): Promise<StripeUser> {
  const response = await axios.get(`https://api.stripe.com/v1/customers/${customerId}`, {
    headers: {
      Authorization: `Bearer ${process.env.STRIPE_API_KEY}`,
    },
  });

  const subscriptions = await axios.get(
    `https://api.stripe.com/v1/customers/${customerId}/subscriptions`,
    {
      headers: {
        Authorization: `Bearer ${process.env.STRIPE_API_KEY}`,
      },
    }
  );

  return {
    id: response.data.id,
    email: response.data.email,
    status: response.data.description || 'unknown',
    subscriptions: subscriptions.data.data,
  };
}

export async function sendSlackNotification(payload: SlackPayload): Promise<void> {
  await axios.post(process.env.SLACK_WEBHOOK_URL, {
    channel: payload.channel,
    text: payload.message,
    ts: Math.floor(Date.now() / 1000),
  });
}

export async function logToDatabase(log: DatabaseLog): Promise<LogResult> {
  const response = await axios.post(process.env.DATABASE_WEBHOOK_URL, {
    customerId: log.customerId,
    status: log.status,
    timestamp: log.timestamp,
  });

  return { id: response.data.insertedId };
}

Create a worker in src/worker.ts:

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

async function runWorker() {
  const worker = await Worker.create({
    workflowsPath: require.resolve('./workflows'),
    activitiesPath: require.resolve('./activities'),
    taskQueue: 'stripe-webhook-queue',
    namespace: 'default',
    workflowFailureExceptionTypes: [Error],
  });

  console.log('Temporal Worker started, listening on queue: stripe-webhook-queue');
  await worker.run();
}

runWorker().catch(console.error);

Finally, trigger a workflow execution in src/run-workflow.ts:

import { Connection, Client } from '@temporalio/client';
import { processStripeWebhook } from './workflows';

async function runWorkflow() {
  const connection = await Connection.connect({ address: 'localhost:7233' });
  const client = new Client({ connection });

  const workflowId = `stripe-webhook-${Date.now()}`;

  const result = await client.workflow.execute(processStripeWebhook, {
    args: ['cus_abc123xyz'],
    taskQueue: 'stripe-webhook-queue',
    workflowId,
  });

  console.log('Workflow completed:', result);
}

runWorkflow().catch(console.error);

Start your worker:

npm run worker

In another terminal, run the workflow:

npm run workflow

You'll see the workflow execute across all three activities: fetch from Stripe, send a Slack message, and log to your database. If any step fails, Temporal retries it automatically. That's the power of durable execution.

Make: The Visual No-Code Platform

Now let's build the exact same workflow in Make.com—the visual way.

Make is cloud-hosted, which means zero infrastructure overhead. You log in, drag modules onto a canvas, and connect them. Each module represents an API call or data transformation. No code required, though you can add JavaScript when needed.

The tradeoff? You pay per operation. Make charges based on the number of "operations" (API calls and data transformations) your workflows perform. If you're running 10,000 Stripe API calls per month, costs add up quickly.

Here's how to replicate the Temporal workflow in Make:

Log into Make and create a new scenario.
Set up the trigger. Add a Webhook module as your trigger. This gives you a webhook URL that Stripe can POST to when events occur.

Make → Webhook → Listen on this URL for Stripe webhook events

Parse the webhook. Add a JSON → Parse JSON module to extract the customerId:

{
  "customerId": "{{trigger.body.data.object.customer}}"
}

Fetch from Stripe. Add a Stripe module (or use HTTP Request):

Module: HTTP → Make a request

URL: https://api.stripe.com/v1/customers/{{customerId}}
Method: GET
Headers: Authorization: Bearer {{env.STRIPE_API_KEY}}

Conditional routing. Add a Router to check if status == 'active':

Router → if status = "active"
  → YES: Send Slack notification
  → NO: Skip notification

Send to Slack. In the YES path, add a Slack module:

Message: User {{firstName}} {{lastName}} ({{email}}) is active with {{subscriptionCount}} subscriptions
Channel: #billing

Log to database. Add an HTTP Request module:

URL: {{env.DATABASE_WEBHOOK_URL}}
Method: POST
Body:

{
  "customerId": "{{customerId}}",
  "status": "{{stripeResponse.status}}",
  "timestamp": "{{now()}}"

Originally published on Automation Insider.

Make vs n8n vs Zapier API integrations 2026

Raizan — Tue, 19 May 2026 08:00:32 +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
Make.com for comparison testing
Text editor (VS Code recommended)
curl or Postman for API testing
Basic understanding of REST APIs

The 2026 Automation Landscape
n8n API Integration Strategy
Make.com's Native Connectors vs Custom APIs
Zapier's Webhook-First Approach
Cost Analysis: Real Numbers
Building Your First Custom Integration
Performance and Scalability
Getting Started

The 2026 Automation Landscape

The workflow automation market has fundamentally shifted since 2024. I've been hands-on with all three platforms—n8n Cloud, Make.com, and Zapier—across 40+ production workflows, and what I'm seeing is a bifurcation: platforms are doubling down on either native integrations or API flexibility. In 2026, that choice matters more than ever.

The reality is brutally simple: if your workflow touches proprietary APIs or niche SaaS tools, you need maximum control. If you're gluing together Slack, Google Sheets, and Stripe, the platform with the most pre-built connectors wins. But here's what nobody tells you—the "best" platform depends entirely on whether you value speed, cost, or architectural ownership.

I built a lead capture and nurturing system last quarter that started on Zapier, migrated to Make.com midway through, and finally landed on n8n. That journey taught me the hard lessons about API rate limits, webhook reliability, and hidden costs that never show up in marketing materials.

n8n API Integration Strategy

n8n remains the most developer-friendly automation platform if you're willing to get your hands dirty with code. In 2026, its appeal lies in one clear advantage: you own the entire workflow architecture.

Here's how I build production-grade API integrations in n8n:

{
  "nodes": [
    {
      "parameters": {
        "url": "https://api.example.com/v1/customers",
        "authentication": "oAuth2",
        "requestMethod": "POST",
        "sendQuery": false,
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "Content-Type",
              "value": "application/json"
            },
            {
              "name": "X-API-Version",
              "value": "2024-12"
            }
          ]
        },
        "bodyParametersJson": "{\n  \"email\": \"{{ $json.userEmail }}\",\n  \"firstName\": \"{{ $json.firstName }}\",\n  \"lastName\": \"{{ $json.lastName }}\",\n  \"metadata\": {\n    \"source\": \"workflow_automation\",\n    \"timestamp\": \"{{ $now.toISOString() }}\"\n  }\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.1,
      "position": [
        1200,
        300
      ],
      "name": "Create Customer in External API"
    },
    {
      "parameters": {
        "conditions": {
          "number": [
            {
              "value1": "{{ $response.statusCode }}",
              "operation": "equal",
              "value2": 201
            }
          ]
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2,
      "position": [
        1400,
        300
      ],
      "name": "Check API Success"
    },
    {
      "parameters": {
        "resource": "message",
        "channel": "#automation-logs",
        "text": "✅ Customer created: {{ $json.data.id }}"
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [
        1600,
        200
      ],
      "name": "Log Success to Slack"
    },
    {
      "parameters": {
        "resource": "message",
        "channel": "#automation-errors",
        "text": "❌ API Error: {{ $json.error.message }} | Status: {{ $response.statusCode }}"
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [
        1600,
        400
      ],
      "name": "Log Error to Slack"
    }
  ],
  "connections": {
    "Create Customer in External API": {
      "main": [
        [
          {
            "node": "Check API Success",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Check API Success": {
      "main": [
        [
          {
            "node": "Log Success to Slack",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Log Error to Slack",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

The critical advantage here is OAuth2 handling without vendor lock-in. When you self-host n8n on Hetzner or DigitalOcean, you control credential storage completely. Your API keys live on your infrastructure.

For webhook-triggered workflows, n8n gives you:

curl -X POST https://your-n8n-instance.com/webhook/api-trigger \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_WEBHOOK_TOKEN" \
  -d '{
    "email": "user@example.com",
    "action": "user_created",
    "timestamp": "2026-01-15T10:30:00Z",
    "payload": {
      "firstName": "John",
      "lastName": "Doe",
      "company": "TechCorp"
    }
  }'

That webhook endpoint you just hit? You own it. No rate-limiting games from Zapier's platform, no "upgrade to Pro" for higher throughput.

Make.com's Native Connectors vs Custom APIs

Make.com (formerly Integromat) competes on connector breadth. In 2026, they've got 1,200+ pre-built modules, and I'll be honest—if your workflow is 80% pre-built connector work, Make.com's visual interface is faster than code.

Here's a Make.com scenario that works beautifully:

{
  "flow": [
    {
      "module": "trigger",
      "type": "webhooks.watch",
      "settings": {
        "url": "https://hooks.make.com/api/webhooks/unique-id",
        "data_structure": {
          "email": "string",
          "action_type": "string",
          "properties": "object"
        }
      }
    },
    {
      "module": "filter",
      "condition": "action_type == 'purchase'",
      "operations": [
        {
          "operand": "{{ trigger.action_type }}",
          "operator": "equal",
          "value": "purchase"
        }
      ]
    },
    {
      "module": "http",
      "type": "make_an_http_request",
      "settings": {
        "url": "https://api.crm.example.com/v2/customers",
        "method": "POST",
        "headers": {
          "Authorization": "Bearer {{ connection.crm_api_key }}",
          "Content-Type": "application/json"
        },
        "body": "{\n  \"email\": \"{{ trigger.email }}\",\n  \"last_action\": \"{{ trigger.action_type }}\",\n  \"custom_fields\": \"{{ trigger.properties }}\"\n}"
      }
    },
    {
      "module": "csv",
      "type": "create_csv",
      "settings": {
        "data": "{{ trigger }}",
        "filename": "webhook_{{ date(now; 'YYYY-MM-DD HH:mm') }}.csv"
      }
    },
    {
      "module": "google_drive",
      "type": "upload_file",
      "settings": {
        "file": "{{ csv.file }}",
        "folder_id": "{{ connection.drive_folder }}"
      }
    }
  ]
}

Make.com's strength is immediate visual feedback. You see the data flowing through each module in real-time. But here's the trade-off: when you need custom JavaScript logic, Make.com's "ScriptableModule" becomes expensive fast. Each custom function runs on their infrastructure at their rates.

The hidden cost of Make.com in 2026: their pricing model charges per operation count, not per workflow. A workflow that processes 100 items across 5 modules costs 500 operations. Scale to 10,000 items daily, and you're looking at significant monthly spend without the visibility you'd have in n8n.

Zapier's Webhook-First Approach

Zapier owns the SMB automation market because they've optimized the path from "I have no automation" to "production workflow" to roughly 10 minutes. In 2026, Zapier's API is mature, but it's built around their cloud infrastructure exclusively.

Here's how Zapier webhooks work:

curl -X POST https://hooks.zapier.com/hooks/catch/YOUR_UNIQUE_ID/YOUR_SECRET/ \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "cust_98765",
    "email": "user@company.com",
    "purchase_amount": 250.00,
    "timestamp": "2026-01-15T14:22:00Z",
    "metadata": {
      "source": "ecommerce_platform",
      "region": "EMEA"
    }
  }'

Zapier catches that webhook, parses it, and routes it through your Zap (their term for workflow). The entire workflow runs on Zapier's cloud infrastructure. You have zero server management, but you also have zero infrastructure control.

The Zapier advantage for teams without DevOps: native integrations with 7,000+ apps. If you need Slack + HubSpot + Stripe + Asana automated together, Zapier has pre-built authentication for all of them. You don't touch an API key directly.

The Zapier disadvantage for teams with serious scale: their free tier is laughably limited (100 tasks/month), their Pro tier hits $49/month minimum, and their highest Enterprise tier doesn't publicly disclose pricing. For a company processing 50,000

Originally published on Automation Insider.

Temporal vs n8n for Microservices Orchestration

Raizan — Mon, 18 May 2026 08:00:43 +0000

What You'll Need

n8n Cloud or self-hosted n8n instance
Hetzner VPS or Contabo VPS for self-hosting Temporal or n8n
DigitalOcean as an alternative hosting provider
Docker and Docker Compose (for local development)
Node.js 18+ installed locally
A REST client like Postman or cURL for testing

What is Temporal?
What is n8n?
Architecture Comparison
Building a Microservice Workflow with Temporal
Building the Same Workflow with n8n
Performance and Scalability
When to Choose Temporal
When to Choose n8n
Getting Started

What is Temporal?

Temporal is an open-source platform designed specifically for orchestrating microservices through a concept called "durable execution." Instead of writing complex logic to handle retries, failures, and distributed state management, Temporal abstracts away the plumbing through workflows and activities written in regular code.

The key innovation is that your code can look synchronous and straightforward, while Temporal handles all the complexity of execution state, resuming from failures, and managing long-running processes. It's built for engineers who want battle-tested infrastructure without reinventing the wheel.

What is n8n?

n8n is a low-code workflow automation platform that I've extensively tested and deployed. It sits at the intersection of no-code simplicity and code flexibility. You build workflows visually using nodes, each representing an integration or custom logic block. n8n excels at connecting SaaS tools, databases, and APIs with minimal custom code.

Unlike Temporal's code-first approach, n8n is visual-first. You design workflows in the UI, configure node parameters, and write JavaScript when you need custom logic.

Architecture Comparison

Temporal uses a server-client architecture where workers register with the Temporal server and poll for tasks. Your application code runs workers that execute activities (actual business logic) and workflows (orchestration logic). The server maintains the event history, ensuring fault tolerance.

n8n runs workflows as directed acyclic graphs (DAGs) where each node passes output to the next. For self-hosted deployments, you run n8n server(s) connected to a PostgreSQL database. Workers pick up jobs from a queue and execute them.

The fundamental difference: Temporal is designed for complex, stateful, long-running processes with guaranteed execution semantics. n8n is optimized for integrations and medium-complexity workflows.

If you're comparing workflow platforms broadly, I've detailed the n8n vs Make vs Zapier pricing breakdown 2026 which provides context on feature trade-offs beyond just Temporal.

Building a Microservice Workflow with Temporal

Let me walk you through a real example: processing customer orders across multiple services. A customer submits an order, you charge their card, reserve inventory, and notify them via email. If any step fails, you need automatic retries and rollback logic.

First, install the Temporal TypeScript SDK:

npm install @temporalio/client @temporalio/worker @temporalio/workflow @temporalio/activities

Create your activities file (activities.ts). Activities are the actual microservice calls:

import axios from 'axios';

export async function chargePayment(orderId: string, amount: number): Promise<string> {
  const response = await axios.post('https://payment-service.internal/charge', {
    orderId,
    amount,
    timestamp: new Date().toISOString()
  }, {
    timeout: 5000,
    headers: { 'Authorization': 'Bearer YOUR_SERVICE_TOKEN' }
  });

  if (response.status !== 200) {
    throw new Error(`Payment failed: ${response.statusText}`);
  }

  return response.data.transactionId;
}

export async function reserveInventory(orderId: string, items: Array<{sku: string, quantity: number}>): Promise<string> {
  const response = await axios.post('https://inventory-service.internal/reserve', {
    orderId,
    items,
    expiryMinutes: 10
  }, {
    timeout: 8000,
    headers: { 'Authorization': 'Bearer YOUR_SERVICE_TOKEN' }
  });

  if (response.status !== 200) {
    throw new Error(`Inventory reservation failed: ${response.statusText}`);
  }

  return response.data.reservationId;
}

export async function sendOrderConfirmation(orderId: string, customerEmail: string, items: any[]): Promise<void> {
  const response = await axios.post('https://email-service.internal/send', {
    to: customerEmail,
    subject: `Order ${orderId} Confirmed`,
    template: 'order-confirmation',
    data: { orderId, items, confirmationTime: new Date().toISOString() }
  }, {
    timeout: 3000,
    headers: { 'Authorization': 'Bearer YOUR_SERVICE_TOKEN' }
  });

  if (response.status !== 200) {
    throw new Error(`Email send failed: ${response.statusText}`);
  }
}

export async function releaseInventory(reservationId: string): Promise<void> {
  await axios.post('https://inventory-service.internal/release', {
    reservationId
  }, {
    timeout: 5000,
    headers: { 'Authorization': 'Bearer YOUR_SERVICE_TOKEN' }
  });
}

Now define the workflow (workflow.ts). This is where Temporal shines—your logic is clean and readable:

import { proxyActivities, RetryPolicy, ApplicationFailure } from '@temporalio/workflow';
import * as activities from './activities';

const { chargePayment, reserveInventory, sendOrderConfirmation, releaseInventory } = proxyActivities<typeof activities>({
  startToCloseTimeout: '10 minutes',
  retry: {
    initialInterval: '1 second',
    maximumInterval: '1 minute',
    maximumAttempts: 3,
    backoffCoefficient: 2.0,
    nonRetryableErrorReasons: ['InvalidOrderId', 'InsufficientFunds']
  }
});

export interface OrderRequest {
  orderId: string;
  customerId: string;
  customerEmail: string;
  items: Array<{ sku: string; quantity: number; price: number }>;
  totalAmount: number;
}

export async function processOrderWorkflow(order: OrderRequest): Promise<{ success: boolean; message: string }> {
  let transactionId: string;
  let reservationId: string;

  try {
    transactionId = await chargePayment(order.orderId, order.totalAmount);
    console.log(`Payment processed: ${transactionId}`);
  } catch (error) {
    return {
      success: false,
      message: `Payment failed for order ${order.orderId}: ${error.message}`
    };
  }

  try {
    reservationId = await reserveInventory(order.orderId, order.items);
    console.log(`Inventory reserved: ${reservationId}`);
  } catch (error) {
    console.log(`Inventory reservation failed, releasing payment hold`);
    await releaseInventory(reservationId);
    return {
      success: false,
      message: `Inventory reservation failed for order ${order.orderId}: ${error.message}`
    };
  }

  try {
    await sendOrderConfirmation(order.orderId, order.customerEmail, order.items);
    console.log(`Confirmation sent to ${order.customerEmail}`);
  } catch (error) {
    console.log(`Email notification failed but order is processing`);
  }

  return {
    success: true,
    message: `Order ${order.orderId} processed successfully`
  };
}

Start a worker that executes these workflows (worker.ts):

import { Worker, NativeConnection } from '@temporalio/worker';
import * as activities from './activities';
import * as workflows from './workflow';

async function runWorker() {
  const connection = await NativeConnection.connect({
    address: 'localhost:7233'
  });

  const worker = await Worker.create({
    connection,
    namespace: 'default',
    taskQueue: 'order-processing',
    workflowsPath: require.resolve('./workflow'),
    activities
  });

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

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

Finally, trigger the workflow from your application (client.ts):

import { Client } from '@temporalio/client';
import { processOrderWorkflow, OrderRequest } from './workflow';

async function submitOrder(order: OrderRequest) {
  const client = new Client({
    connection: { address: 'localhost:7233' }
  });

  const handle = await client.workflow.start(processOrderWorkflow, {
    args: [order],
    taskQueue: 'order-processing',
    workflowId: `order-${order.orderId}-${Date.now()}`,
    memo: {
      customerId: order.customerId,
      totalAmount: order.totalAmount.toString()
    }
  });

  console.log(`Workflow started: ${handle.workflowId}`);

  const result = await handle.result();
  console.log('Workflow result:', result);
  return result;
}

submitOrder({
  orderId: 'ORD-12345',
  customerId: 'CUST-789',
  customerEmail: 'customer@example.com',
  items: [
    { sku: 'SKU-001', quantity: 2, price: 29.99 },
    { sku: 'SKU-002', quantity: 1, price: 49.99 }
  ],
  totalAmount: 109.97
});

This workflow demonstrates Temporal's power: if your payment microservice is down, Temporal automatically retries. If the worker crashes mid-execution, it resumes exactly where it left off. No state management code needed.

Building the Same Workflow with n8n

Now let's build the same order processing workflow in n8n. You'll use the visual workflow editor and HTTP nodes to call your microservices.

Create a new workflow in n8n and add a webhook trigger node to receive order submissions:

{
  "name": "HTTP In - Order Submission",
  "type": "n8n-nodes-base.httpWebhook",
  "parameters": {
    "path": "/order-webhook",
    "httpMethod": "POST",
    "responseMode": "onReceived"
  }
}

Add a Set node to extract and structure the incoming order data:

{
  "name": "Structure Order Data",
  "type": "n8n-nodes-base.set",
  "parameters": {
    "assignments": {
      "assignments": [
        {
          "name": "orderId",
          "value": "={{$json.body.orderId}}",
          "type": "string"
        },
        {
          "name": "customerId",
          "value": "={{$json.body.custom

Originally published on Automation Insider.

Building Custom Webhooks vs Using n8n Triggers

Raizan — Sun, 17 May 2026 08:00:28 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting custom webhook servers
DigitalOcean as an alternative hosting option
Node.js (v18+) if building custom webhooks
A code editor (VS Code recommended)
Basic knowledge of REST APIs and JSON

What You'll Need
Understanding Webhooks and Triggers
When to Build Custom Webhooks
Building a Custom Webhook Server
Using n8n Triggers: The Simpler Path
Performance and Cost Comparison
Getting Started

Understanding Webhooks and Triggers

I've spent years building automation systems, and the webhook vs. trigger question comes up constantly. Let me cut through the noise: they're solving the same problem differently.

A webhook is essentially an HTTP POST request sent from one service to another when something happens. It's a push notification. Your app pushes data to n8n when an event occurs. A trigger, in n8n's context, is a built-in listener that polls or subscribes to specific events within a service and automatically starts your workflow.

The core difference? Control and flexibility versus ease of setup.

When you build a custom webhook, you control the exact payload, authentication, retry logic, and event timing. When you use n8n's built-in triggers, you get instant integration with thousands of apps but less granular control. I've found myself using both in the same project—triggers for simple integrations and custom webhooks for complex, high-volume systems.

When to Build Custom Webhooks

I reach for custom webhooks in these scenarios:

Legacy system integration. If you're connecting to a 15-year-old internal database that n8n doesn't have a native connector for, custom webhooks are your answer. The legacy system pushes data to your webhook endpoint, n8n processes it, and downstream tools consume the results.

High-volume event handling. When you're processing thousands of events daily, webhook efficiency matters. Webhooks are push-based (event-driven), so you're not wasting compute cycles polling endpoints that haven't changed.

Custom authentication. Some internal APIs use proprietary auth schemes. Building a custom webhook lets you handle mutual TLS certificates, custom headers, or API tokens that n8n's standard connectors don't support.

Payload transformation at the source. Sometimes it's cleaner to filter or reshape data at the webhook source rather than inside n8n. This reduces workflow complexity and saves processing time.

Building a Custom Webhook Server

Let me show you a production-ready webhook server. I've simplified this, but it's what I run on a Hetzner VPS handling thousands of daily events.

First, your Node.js server:

const express = require('express');
const crypto = require('crypto');
const axios = require('axios');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;
const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET || 'your-secret-key-change-this';
const N8N_WEBHOOK_URL = process.env.N8N_WEBHOOK_URL;

app.use(express.json());

function verifySignature(req, secret) {
  const signature = req.headers['x-webhook-signature'];
  const timestamp = req.headers['x-webhook-timestamp'];
  const body = JSON.stringify(req.body);

  const message = `${timestamp}.${body}`;
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(message)
    .digest('hex');

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

app.post('/webhook/events', async (req, res) => {
  try {
    if (!verifySignature(req, WEBHOOK_SECRET)) {
      return res.status(401).json({ error: 'Invalid signature' });
    }

    const payload = req.body;
    const eventType = payload.event_type;
    const timestamp = new Date().toISOString();

    console.log(`[${timestamp}] Received ${eventType} event`);

    const enrichedPayload = {
      original_event: payload,
      received_at: timestamp,
      event_type: eventType,
      source_ip: req.ip,
      processed: false
    };

    try {
      const response = await axios.post(N8N_WEBHOOK_URL, enrichedPayload, {
        headers: {
          'Content-Type': 'application/json'
        },
        timeout: 30000
      });

      enrichedPayload.processed = true;
      enrichedPayload.n8n_response_code = response.status;

      console.log(`[${timestamp}] Successfully forwarded to n8n`);
      return res.status(200).json({ 
        success: true, 
        message: 'Event received and forwarded',
        event_id: enrichedPayload.event_id
      });
    } catch (error) {
      console.error(`[${timestamp}] n8n forwarding failed:`, error.message);

      if (error.response?.status >= 500) {
        return res.status(202).json({ 
          success: false,
          message: 'Event queued for retry',
          error: error.message
        });
      }

      return res.status(400).json({ 
        success: false,
        message: 'Failed to process event',
        error: error.message
      });
    }
  } catch (error) {
    console.error('Webhook handler error:', error);
    return res.status(500).json({ error: 'Internal server error' });
  }
});

app.get('/health', (req, res) => {
  res.status(200).json({ status: 'ok', timestamp: new Date().toISOString() });
});

app.listen(PORT, () => {
  console.log(`Webhook server running on port ${PORT}`);
  console.log(`Health check: http://localhost:${PORT}/health`);
});

Your .env file:

PORT=3000
WEBHOOK_SECRET=your-super-secret-key-at-least-32-characters-long
N8N_WEBHOOK_URL=https://your-n8n-instance.com/webhook/your-webhook-path
NODE_ENV=production

Your package.json:

{
  "name": "webhook-server",
  "version": "1.0.0",
  "description": "Custom webhook server for n8n",
  "main": "server.js",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  },
  "dependencies": {
    "express": "^4.18.2",
    "axios": "^1.6.0",
    "dotenv": "^16.3.1"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  }
}

Install dependencies:

npm install

Deploy this to DigitalOcean or Contabo. Use PM2 to keep it running:

npm install -g pm2
pm2 start server.js --name webhook-server
pm2 save
pm2 startup

Now, in your source system (the one sending events), you'd call your webhook like this:

curl -X POST https://your-webhook-server.com/webhook/events \
  -H "Content-Type: application/json" \
  -H "x-webhook-signature: $(echo -n '1702000000.{"event_type":"user.created"}' | openssl dgst -sha256 -hmac 'your-secret-key' | cut -d' ' -f2)" \
  -H "x-webhook-timestamp: 1702000000" \
  -d '{"event_type":"user.created","user_id":"12345","email":"user@example.com"}'

Using n8n Triggers: The Simpler Path

Now let me show you how the same flow works with n8n Cloud.

With n8n's native triggers, you skip the custom server entirely. Instead, you add a trigger node directly in your workflow. Here's what that looks like:

Create a new workflow in n8n:

Click Add trigger
Search for Webhook
Select Webhook

In the Webhook trigger node configuration:

HTTP Method: POST
Path: /my-webhook-path
Authentication: None (or Basic Auth if needed)
Response Mode: On Received
Execution Data: First incoming data

Your n8n node setup:

{
  "node": "Webhook",
  "type": "n8n-nodes-base.webhook",
  "typeVersion": 1,
  "position": [250, 300],
  "parameters": {
    "httpMethod": "POST",
    "path": "my-webhook-path",
    "responseMode": "onReceived",
    "options": {
      "authenticationMethod": "none"
    }
  }
}

The webhook URL n8n generates looks like:

https://your-n8n-instance.com/webhook/my-webhook-path

You send data to that URL:

curl -X POST https://your-n8n-instance.com/webhook/my-webhook-path \
  -H "Content-Type: application/json" \
  -d '{"user_id":"12345","event":"signup"}'

Next, add a Set node to process the incoming data:

{
  "node": "Set",
  "type": "n8n-nodes-base.set",
  "typeVersion": 3,
  "position": [450, 300],
  "parameters": {
    "mode": "manual",
    "assignments": {
      "assignments": [
        {
          "id": "1",
          "name": "event_type",
          "value": "={{ $json.event }}",
          "type": "string"
        },
        {
          "id": "2",
          "name": "user_id",
          "value": "={{ $json.user_id }}",
          "type": "string"
        },
        {
          "id": "3",
          "name": "processed_at",
          "value": "={{ now().toISOString() }}",
          "type": "string"
        }
      ]
    }
  }
}

Then add your downstream action—maybe sending to a database or another service. If you're integrating with OAuth2 for services like Google Workspace, I'd recommend reading my guide on OAuth2 for Beginners: Connecting APIs Without the Pain.

The beauty of n8n triggers is speed. No server setup, no authentication to build, automatic retries, and logging built in. The tradeoff is less control over how events are filtered or transformed before reaching your workflow.

Performance and Cost Comparison

Here's what I've learned running both approaches:

Custom Webhooks:

Latency: 50-150ms end-to-end (after your server

Originally published on Automation Insider.

How I Run 3 Automated Systems on a Single $7/Month VPS

Raizan — Fri, 08 May 2026 08:00:28 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting
Namecheap if domain needed
SSH client (built into Mac/Linux, PuTTY for Windows)
Basic command-line familiarity

The Reality of Running Multiple Systems on Minimal Infrastructure
System 1: Lead Capture to CRM Pipeline
System 2: Daily Content Publishing Scheduler
System 3: Performance Monitoring and Alert Relay
Resource Optimization Strategies
Getting Started with Your Own Setup

The Reality of Running Multiple Systems on Minimal Infrastructure {#reality}

I manage three separate automation workflows on a $7/month VPS from Contabo VPS, and honestly, it's become my favorite experiment in lean operations. Before you roll your eyes thinking this is some clickbait nonsense—it's not. It works. But it requires intentional architecture choices.

Most people assume you need separate servers, managed cloud services, or at minimum a $20+ VPS tier. I'm here to tell you that's marketing speak. I've consolidated workflows that would typically cost $60–80 per month in SaaS fees into a single machine. The key isn't magic; it's understanding resource constraints and designing workflows that respect them.

When I started, I had a naive approach: just install n8n on a cheap server and throw everything at it. The VPS crawled. CPU usage spiked unpredictably. Workflows would timeout. Then I learned what actually matters: memory footprint, database efficiency, and intelligent scheduling. This post walks through exactly how I solved each problem.

System 1: Lead Capture to CRM Pipeline {#system-1-lead-capture}

My first automated system grabs leads from a web form, validates them, and pipes them into my CRM—no manual touch. This runs 24/7 and is the most critical workflow.

Setting Up n8n on Your VPS

First, SSH into your Contabo VPS and get n8n installed:

curl -fsSL https://raw.githubusercontent.com/n8n-io/n8n/master/packages/node-dev/bin/n8n | bash

Create a dedicated user for n8n to avoid permission headaches:

sudo useradd -m -s /bin/bash n8n
sudo su - n8n

Install Node.js version 18 (n8n's sweet spot for performance):

curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

Install n8n globally:

npm install -g n8n

Create a systemd service file so n8n starts automatically:

sudo nano /etc/systemd/system/n8n.service

Paste this configuration:

[Unit]
Description=n8n Workflow Automation
After=network.target

[Service]
Type=simple
User=n8n
WorkingDirectory=/home/n8n
Environment="NODE_ENV=production"
Environment="N8N_PORT=5678"
Environment="N8N_PROTOCOL=https"
Environment="N8N_HOST=your-domain.com"
Environment="N8N_SECURE_COOKIE=true"
Environment="N8N_DB_TYPE=sqlite"
Environment="N8N_DB_SQLITE_DB_FILE=/home/n8n/.n8n/database.sqlite"
ExecStart=/usr/bin/n8n start
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Enable and start the service:

sudo systemctl daemon-reload
sudo systemctl enable n8n
sudo systemctl start n8n

Set up Nginx as a reverse proxy (this protects n8n and handles SSL):

sudo apt-get install -y nginx certbot python3-certbot-nginx

Create an Nginx config:

sudo nano /etc/nginx/sites-available/n8n

Add this:

server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://127.0.0.1:5678;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Enable the site and get SSL:

sudo ln -s /etc/nginx/sites-available/n8n /etc/nginx/sites-enabled/n8n
sudo certbot certonly --standalone -d your-domain.com

Update Nginx to use HTTPS:

sudo nano /etc/nginx/sites-available/n8n

Replace with:

server {
    listen 80;
    server_name your-domain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name your-domain.com;

    ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    location / {
        proxy_pass http://127.0.0.1:5678;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Reload Nginx:

sudo systemctl reload nginx

The Lead Workflow

Inside n8n, I built this workflow that's been processing 50–100 leads daily:

Webhook trigger – listens for form submissions
Validation node – checks email format and required fields
Deduplication – queries SQLite to prevent duplicate entries
CRM HTTP call – POSTs to my CRM API
Slack notification – alerts me of new qualified leads

Here's the actual workflow JSON structure (simplified for clarity, but production-ready):

{
  "nodes": [
    {
      "parameters": {
        "path": "webhook/lead-capture",
        "responseMode": "onReceived",
        "responseData": "customJson",
        "responseValue": "{\"status\": \"received\"}"
      },
      "id": "webhook-trigger",
      "name": "Lead Form Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [250, 300]
    },
    {
      "parameters": {
        "conditions": {
          "string": [
            {
              "value1": "{{ $json.email }}",
              "operation": "regex",
              "value2": "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
            },
            {
              "value1": "{{ $json.name }}",
              "operation": "isEmpty",
              "value2": null
            }
          ]
        }
      },
      "id": "if-valid",
      "name": "Validate Email & Name",
      "type": "n8n-nodes-base.if",
      "typeVersion": 2,
      "position": [550, 300]
    },
    {
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT COUNT(*) as count FROM leads WHERE email = '{{ $json.email }}' AND created_at > datetime('now', '-7 days')",
        "database": "/home/n8n/.n8n/database.sqlite"
      },
      "id": "check-duplicate",
      "name": "Check Duplicate (Last 7 Days)",
      "type": "n8n-nodes-base.sqlite",
      "typeVersion": 1,
      "position": [850, 300]
    },
    {
      "parameters": {
        "url": "https://api.your-crm.com/leads",
        "method": "POST",
        "headers": {
          "Authorization": "Bearer {{ $env.CRM_API_KEY }}",
          "Content-Type": "application/json"
        },
        "body": {
          "name": "{{ $json.name }}",
          "email": "{{ $json.email }}",
          "phone": "{{ $json.phone }}",
          "message": "{{ $json.message }}",
          "source": "web_form"
        }
      },
      "id": "post-to-crm",
      "name": "Send to CRM",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.1,
      "position": [1150, 300]
    },
    {
      "parameters": {
        "text": "🎯 New Lead: {{ $json.name }} ({{ $json.email }})"
      },
      "id": "slack-notify",
      "name": "Slack Alert",
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [1450, 300]
    }
  ],
  "connections": {
    "webhook-trigger": {
      "main": [
        [
          {
            "node": "if-valid",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "if-valid": {
      "main": [
        [
          {
            "node": "check-duplicate",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "check-duplicate": {
      "main": [
        [
          {
            "node": "post-to-crm",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "post-to-crm": {
      "main": [
        [
          {
            "node": "slack-notify",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

The deduplication step is crucial on a shared VPS. Instead of spamming your CRM or burning API rate limits, I query SQLite locally first. This is where choosing the right database matters—I cover this decision deeper in my guide on SQLite vs PostgreSQL for Small Projects: When to Use Which.

Originally published on Automation Insider.

Cron Jobs Explained: Scheduling Automated Tasks on Linux

Raizan — Thu, 07 May 2026 08:00:33 +0000

What You'll Need

n8n Cloud or self-hosted n8n (optional, for automation integration)
Hetzner VPS, Contabo VPS, or DigitalOcean for running cron jobs
Namecheap if you need a domain for your automation
Linux server access (Ubuntu 20.04 LTS or later recommended)
Basic command-line familiarity

Understanding Cron: The Basics
Crontab Syntax Breakdown
Creating and Managing Your First Cron Job
Real-World Examples and Use Cases
Debugging and Monitoring Cron Jobs
Getting Started

Understanding Cron: The Basics

I'll be honest—when I first encountered cron jobs, I thought they were some obscure DevOps sorcery. They're actually one of the simplest yet most powerful tools in Linux. A cron job is just a scheduled task that runs automatically at specific times or intervals without you touching a keyboard. It's been the backbone of server automation since 1975, and it still works beautifully today.

Think of cron as your personal assistant that never sleeps. You give it instructions once, and it executes them endlessly—every minute, every hour, every month, or whenever you specify. Whether you're backing up databases, clearing log files, sending status reports, or pulling crypto prices for alerts, cron handles it silently in the background.

The beauty of cron is its simplicity. Unlike more complex automation platforms, it requires no UI, no cloud connection, and no monthly subscription. If you've got a Linux server—whether it's a Hetzner VPS or a DigitalOcean droplet—you've already got cron built in.

However, if you're managing dozens of workflows across multiple systems, you might eventually want to explore solutions like n8n Cloud, which centralizes your automation logic. But let's not get ahead of ourselves. Cron is perfect for many use cases, and understanding it is fundamental.

Crontab Syntax Breakdown

The magic happens in a file called a crontab (cron table). Each line in your crontab represents one scheduled task, and each line follows this exact format:

┌───────────── minute (0 - 59)
│ ┌───────────── hour (0 - 23)
│ │ ┌───────────── day of month (1 - 31)
│ │ │ ┌───────────── month (1 - 12)
│ │ │ │ ┌───────────── day of week (0 - 7) (0 and 7 are Sunday)
│ │ │ │ │
│ │ │ │ │
* * * * * command-to-execute

Let me break this down with actual examples so you see how it works:

0 2 * * * /home/user/backup.sh

This runs /home/user/backup.sh at 2:00 AM every single day. The first 0 means minute 0 (top of the hour), 2 is 2 AM, and the three asterisks mean "every day, every month, any day of week."

*/15 * * * * /usr/bin/python3 /home/user/check_status.py

The */15 means "every 15 minutes." This Python script runs four times per hour, all day, every day.

0 0 1 * * /home/user/monthly_report.sh

This runs on the first day of every month at midnight. Perfect for monthly tasks.

30 3 * * 1 /home/user/weekly_backup.sh

This runs every Monday at 3:30 AM. The 1 represents Monday (0=Sunday, 1=Monday, etc.).

Here's a quick reference table for common time expressions:

@yearly      0 0 1 1 *     (once per year on January 1st)
@monthly     0 0 1 * *     (once per month on the 1st)
@weekly      0 0 * * 0     (once per week on Sunday at midnight)
@daily       0 0 * * *     (once per day at midnight)
@hourly      0 * * * *     (once per hour)
@reboot      -             (when the system boots up)

These shortcuts make crontabs more readable. @hourly is much cleaner than 0 * * * *.

Creating and Managing Your First Cron Job

Let's get practical. I'm going to walk you through creating a real cron job from scratch.

Step 1: Open Your Crontab

On your Linux server, open the crontab editor:

crontab -e

This opens your personal crontab in your default editor (usually nano or vim). If it's your first time, you'll see a blank file with some commented instructions at the top.

Step 2: Write Your Script

First, let's create the script you want to run. I'll create a simple backup script. Open a new file:

nano /home/user/backup_logs.sh

Add this content:

#!/bin/bash

BACKUP_DIR="/backups"
SOURCE_DIR="/var/log"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR

tar -czf $BACKUP_DIR/logs_backup_$DATE.tar.gz $SOURCE_DIR

find $BACKUP_DIR -name "logs_backup_*.tar.gz" -mtime +7 -delete

echo "Backup completed at $(date)" >> /var/log/backup.log

Save the file (Ctrl+O, Enter, Ctrl+X in nano), then make it executable:

chmod +x /home/user/backup_logs.sh

Step 3: Add the Cron Job

Now open your crontab again:

crontab -e

Add this line at the bottom:

0 3 * * * /home/user/backup_logs.sh

This runs your backup script every day at 3:00 AM.

Step 4: Verify It's Scheduled

List your cron jobs to confirm they were added:

crontab -l

You should see your new job listed. That's it—you're done. The script will run automatically from now on.

Real-World Examples and Use Cases

Let me show you some practical cron jobs I've actually used in production environments. These patterns solve real problems.

Database Backups Every 6 Hours

0 */6 * * * /usr/bin/mysqldump -u root -pYourPassword database_name > /backups/db_$(date +\%Y\%m\%d_\%H\%M\%S).sql

This backs up your MySQL database every 6 hours. The backticks escape the date command so it's evaluated at runtime.

Clean Up Old Log Files

0 2 * * * find /var/log/nginx -name "*.log" -mtime +30 -delete

Runs at 2 AM daily, deleting nginx logs older than 30 days. Essential for preventing disk space issues.

Sync Files to Remote Server

30 4 * * * rsync -avz --delete /home/user/data/ user@remote.server:/backup/data/

Syncs your data directory to a remote server at 4:30 AM every day. Great for distributed backups.

Check Website Uptime

*/5 * * * * /home/user/check_uptime.sh

Here's what check_uptime.sh might look like:

#!/bin/bash

WEBSITE="https://example.com"
LOGFILE="/var/log/uptime_check.log"

if curl -s --max-time 5 "$WEBSITE" > /dev/null; then
    echo "$(date) - $WEBSITE is UP" >> $LOGFILE
else
    echo "$(date) - $WEBSITE is DOWN - sending alert" >> $LOGFILE
    echo "Website down!" | mail -s "Alert: $WEBSITE Down" admin@example.com
fi

This checks every 5 minutes and sends an email if the site is down.

Generate Daily Reports

0 8 * * * /usr/bin/python3 /home/user/generate_report.py

Run a Python script at 8 AM to generate reports. Here's a sample script:

#!/usr/bin/env python3

import subprocess
from datetime import datetime

report_date = datetime.now().strftime("%Y-%m-%d")
output_file = f"/reports/report_{report_date}.txt"

with open(output_file, "w") as f:
    f.write(f"Daily Report for {report_date}\n")
    f.write("=" * 40 + "\n")

    disk_usage = subprocess.check_output(["df", "-h"], text=True)
    f.write("Disk Usage:\n")
    f.write(disk_usage)
    f.write("\n")

    memory = subprocess.check_output(["free", "-h"], text=True)
    f.write("Memory Status:\n")
    f.write(memory)

print(f"Report generated: {output_file}")

Restart Services If Down

*/10 * * * * /home/user/check_service.sh

Here's the script:

#!/bin/bash

SERVICE_NAME="nginx"

if ! systemctl is-active --quiet $SERVICE_NAME; then
    echo "$(date) - $SERVICE_NAME was down, restarting..." >> /var/log/service_restarts.log
    systemctl restart $SERVICE_NAME
fi

Checks every 10 minutes and restarts nginx if it's not running.

If you're automating data collection across multiple systems, you might eventually want to centralize your workflows. Check out our guide on How to Set Up a VPS for Automation (Hetzner vs Contabo vs Railway) to understand hosting options that work well with automation systems.

Debugging and Monitoring Cron Jobs

Here's where most people struggle. A cron job runs silently, and when something breaks, you won't know unless you look at the logs.

Check If Cron Daemon Is Running

sudo service cron status

On some systems:

sudo systemctl status cron

If it's not running:

sudo systemctl start cron
sudo systemctl enable cron

View Cron Logs (Ubuntu/Debian)

sudo grep CRON /var/log/syslog

Or on newer systems:

sudo journalctl -u cron --no-pager

This shows all cron activity. You'll see lines like:

Nov 15 03:00:01 myserver CRON[12345]: (user) CMD (/home/user/backup_logs.sh)

Capture Output and Errors

Modify your crontab to save output:

0 3 * * * /home/user/backup_

Originally published on Automation Insider.

SQLite vs PostgreSQL for Small Projects: When to Use Which

Raizan — Wed, 06 May 2026 08:00:36 +0000

What You'll Need

n8n Cloud or self-hosted n8n for workflow automation
Hetzner VPS or Contabo VPS for hosting PostgreSQL instances
DigitalOcean as an alternative cloud provider
Namecheap for domain registration (optional)
SQLite (built-in to most systems) or PostgreSQL (free, open-source)

Understanding the Fundamentals
SQLite: Lightweight and Local
PostgreSQL: Scalable and Powerful
Head-to-Head Comparison
Migration Strategies
Real-World Use Cases
Getting Started

Understanding the Fundamentals

I've spent the last five years building small projects that started simple and ended up needing serious database muscle. The SQLite vs PostgreSQL decision isn't academic—it's the difference between shipping fast today and refactoring in panic mode six months from now.

SQLite is a file-based relational database that lives on your machine. No server, no network calls, no complexity. PostgreSQL is a heavyweight champion: a full-featured relational database server that handles concurrent users, complex transactions, and enterprise-grade reliability.

The wrong choice wastes weeks. The right one lets you scale without rewrites.

SQLite: Lightweight and Local

I reach for SQLite when I'm building a prototype, a CLI tool, or anything that doesn't need remote access. It's bundled with Python, Node.js, and most runtimes. Installation? You already have it.

SQLite stores everything in a single file. Your entire database is just database.db sitting on disk. This means:

Zero configuration
Instant backups (copy the file)
Perfect for local development
No network overhead
ACID compliance out of the box

Here's how you'd initialize a basic SQLite database in Node.js:

const sqlite3 = require('sqlite3').verbose();

const db = new sqlite3.Database('./myapp.db', (err) => {
  if (err) {
    console.error(err.message);
  } else {
    console.log('Connected to SQLite database');
  }
});

db.serialize(() => {
  db.run(`CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  )`);

  db.run(`CREATE TABLE IF NOT EXISTS posts (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL,
    title TEXT NOT NULL,
    content TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
  )`);

  console.log('Tables created successfully');
});

db.close((err) => {
  if (err) {
    console.error(err.message);
  }
});

Now let's add some data:

const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database('./myapp.db');

db.serialize(() => {
  const stmt = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');

  stmt.run('Alice Chen', 'alice@example.com', function(err) {
    if (err) console.error(err);
    else console.log('Inserted user with ID:', this.lastID);
  });

  stmt.run('Bob Martinez', 'bob@example.com', function(err) {
    if (err) console.error(err);
    else console.log('Inserted user with ID:', this.lastID);
  });

  stmt.finalize();

  db.all('SELECT * FROM users', [], (err, rows) => {
    if (err) throw err;
    console.log('All users:', rows);
  });
});

db.close();

SQLite handles single-process or light concurrent access beautifully. If you're building a Electron app, a mobile backend, or a data pipeline that runs on one machine, SQLite is your answer.

The catch? SQLite struggles with concurrent writes. It locks the entire database file during writes, which works fine for one user but explodes with multiple simultaneous requests. It also doesn't support replication or clustering. Scale beyond 100,000 records with multiple concurrent users, and you'll hit limitations.

PostgreSQL: Scalable and Powerful

PostgreSQL is the opposite: a client-server database that handles thousands of concurrent connections, advanced data types, full-text search, JSON storage, and nearly infinite scalability.

I use PostgreSQL when:

Multiple users hit the database simultaneously
I need advanced queries or complex joins
I'm building an API that serves a web or mobile app
I plan to grow beyond prototype stage
I need features like stored procedures or custom types

Setting up PostgreSQL requires more work. I typically deploy it on a Hetzner VPS or DigitalOcean using Docker:

version: '3.8'
services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: securepassword123
      POSTGRES_DB: myapp_db
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U appuser"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  postgres_data:

Run this with:

docker-compose up -d

Now connect from Node.js using the pg library:

const { Pool } = require('pg');

const pool = new Pool({
  user: 'appuser',
  password: 'securepassword123',
  host: 'localhost',
  port: 5432,
  database: 'myapp_db'
});

pool.on('error', (err) => {
  console.error('Unexpected error on idle client', err);
});

const createTables = async () => {
  const client = await pool.connect();
  try {
    await client.query(`
      CREATE TABLE IF NOT EXISTS users (
        id SERIAL PRIMARY KEY,
        name VARCHAR(255) NOT NULL,
        email VARCHAR(255) UNIQUE NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
      )
    `);

    await client.query(`
      CREATE TABLE IF NOT EXISTS posts (
        id SERIAL PRIMARY KEY,
        user_id INTEGER NOT NULL REFERENCES users(id),
        title VARCHAR(255) NOT NULL,
        content TEXT,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
      )
    `);

    console.log('Tables created successfully');
  } finally {
    client.release();
  }
};

createTables().catch(console.error);

Insert and query data:

const { Pool } = require('pg');

const pool = new Pool({
  user: 'appuser',
  password: 'securepassword123',
  host: 'localhost',
  port: 5432,
  database: 'myapp_db'
});

const addUser = async (name, email) => {
  const result = await pool.query(
    'INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id, name, email, created_at',
    [name, email]
  );
  return result.rows[0];
};

const getAllUsers = async () => {
  const result = await pool.query('SELECT id, name, email, created_at FROM users ORDER BY created_at DESC');
  return result.rows;
};

const getUserWithPosts = async (userId) => {
  const result = await pool.query(`
    SELECT 
      u.id, u.name, u.email, u.created_at,
      json_agg(json_build_object('id', p.id, 'title', p.title, 'content', p.content)) as posts
    FROM users u
    LEFT JOIN posts p ON u.id = p.user_id
    WHERE u.id = $1
    GROUP BY u.id, u.name, u.email, u.created_at
  `, [userId]);
  return result.rows[0];
};

(async () => {
  try {
    const newUser = await addUser('Carol Davis', 'carol@example.com');
    console.log('Created user:', newUser);

    const allUsers = await getAllUsers();
    console.log('All users:', allUsers);

    const userDetail = await getUserWithPosts(newUser.id);
    console.log('User with posts:', userDetail);
  } catch (err) {
    console.error('Database error:', err);
  } finally {
    await pool.end();
  }
})();

PostgreSQL also handles JSON natively, which is perfect if you're storing flexible data. Notice in the query above I'm using json_agg and json_build_object—these are PostgreSQL features that SQLite can't match.

Head-to-Head Comparison

Here's a decision matrix I use:

Choose SQLite if:

Your app is a single-user tool or runs on one machine
You're prototyping or building a proof of concept
You need zero DevOps burden
File-based storage works for your architecture
You're embedding a database in a game, desktop app, or CLI tool
You have fewer than 10,000 daily transactions

Choose PostgreSQL if:

Multiple users access the database simultaneously
You're building a web API or SaaS product
You need replication, backups, or high availability
Your data is complex or relational with many joins
You plan to scale beyond prototype stage
You need features like JSONB, full-text search, or arrays
Your infrastructure already supports Docker or cloud deployments

I've also seen projects successfully run SQLite at scale when stored on high-performance NVMe drives and accessed by a single process (think a data warehouse that loads once daily). Don't assume SQLite is always "too small"—it's about your access pattern, not your dataset size.

Migration Strategies

I've migrated three projects from SQLite to PostgreSQL. Here's how to do it without losing sleep.

First, export your SQLite data as SQL:

sqlite3 myapp.db .dump > backup.sql

This creates a portable SQL file. Now here's the tricky part: SQLite and PostgreSQL have syntax differences. SQLite's AUTOINCREMENT and CURRENT_TIMESTAMP don't translate directly.

Create a migration script that handles these differences:

import sqlite3
import psycopg2
from psycopg2 import sql
import sys

sqlite_db = 'myapp.db'
pg_host = 'localhost'
pg_user = 'appuser'
pg_password = 'securepassword123'
pg_db = 'myapp_db'

sqlite_conn = sqlite3.connect(sqlite_db)
sqlite_cursor = sqlite_conn.cursor()

pg_conn = psycopg2.connect(
    host=pg_host,
    user=pg_user,
    password=pg_password,
    database=pg_db
)
pg_cursor = pg_conn.cursor()

sqlite_cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
tables = sqlite_cursor.fetchall()

for table_name in tables:
    table = table_name[0]

Originally published on Automation Insider.

How to Build a YouTube Upload Bot with Node.js and OAuth2

Raizan — Tue, 05 May 2026 08:00:38 +0000

What You'll Need

n8n Cloud or self-hosted n8n for workflow orchestration
Hetzner VPS or Contabo VPS for hosting your Node.js bot
Namecheap if you need a domain for webhooks
Node.js 18+ installed locally
A Google/YouTube developer account with API credentials
FFmpeg installed (for video processing)
Basic understanding of OAuth2 flow

Understanding the YouTube Upload Workflow
Setting Up Google OAuth2 Credentials
Building the Core Node.js Bot
Handling OAuth2 Token Refresh
Implementing Video Upload Logic
Deploying and Monitoring
Getting Started

Understanding the YouTube Upload Workflow

I've built dozens of YouTube automation workflows over the past three years, and the pattern is always the same: authenticate once, grab an access token, upload videos, refresh tokens before they expire. The tricky part isn't the code—it's understanding when and why OAuth2 needs refreshing, and handling edge cases like failed uploads or network timeouts.

YouTube's Data API v3 requires OAuth2 because you're acting on behalf of a user's account. Unlike simple API keys, OAuth2 gives you delegated access that users can revoke anytime. Your bot will need to:

Exchange a refresh token for a short-lived access token
Use that token to upload video files to YouTube
Update video metadata (title, description, tags, privacy settings)
Handle token expiration gracefully

The beauty of building this in Node.js is speed and ecosystem maturity. Libraries like googleapis and dotenv are battle-tested in production. If you're comparing lightweight AI options for automating video descriptions or titles during upload, Claude Haiku vs GPT-4o Mini for Automation Pipelines walks through real trade-offs.

Setting Up Google OAuth2 Credentials

Head to Google Cloud Console and create a new project. I'll walk through the exact steps:

Click "Select a Project" → "New Project"
Name it something obvious like youtube-uploader-bot
Once created, navigate to "APIs & Services" → "Credentials"
Click "Create Credentials" → "OAuth 2.0 Client ID"
You'll be prompted to create a consent screen first. Choose "External" for user type
Fill in the app name, user support email, and developer contact
On "Scopes," add https://www.googleapis.com/auth/youtube.upload
Back to Credentials, create an OAuth 2.0 Client ID as a "Desktop application"
Download the JSON file—this contains your client_id and client_secret

Save that JSON file as credentials.json in your project root. Never commit this to git.

Now create a .env file to store sensitive values:

GOOGLE_CLIENT_ID=YOUR_CLIENT_ID_HERE
GOOGLE_CLIENT_SECRET=YOUR_CLIENT_SECRET_HERE
REDIRECT_URI=http://localhost:3000/oauth2callback
YOUTUBE_CHANNEL_ID=UCXXXXXXXXXXXXXXXXXX
NODE_ENV=production

Building the Core Node.js Bot

Install dependencies first:

npm init -y
npm install googleapis dotenv express axios path os stream

Create auth.js to handle the OAuth2 flow:

const { google } = require('googleapis');
const fs = require('fs');
require('dotenv').config();

const oauth2Client = new google.auth.OAuth2(
  process.env.GOOGLE_CLIENT_ID,
  process.env.GOOGLE_CLIENT_SECRET,
  process.env.REDIRECT_URI
);

function getAuthUrl() {
  const scopes = ['https://www.googleapis.com/auth/youtube.upload'];

  const url = oauth2Client.generateAuthUrl({
    access_type: 'offline',
    scope: scopes,
    prompt: 'consent'
  });

  return url;
}

function saveRefreshToken(tokens) {
  const tokenPath = 'tokens.json';
  fs.writeFileSync(tokenPath, JSON.stringify(tokens, null, 2));
  console.log(`Refresh token saved to ${tokenPath}`);
}

function loadRefreshToken() {
  const tokenPath = 'tokens.json';
  if (fs.existsSync(tokenPath)) {
    const tokens = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
    oauth2Client.setCredentials(tokens);
    return tokens;
  }
  return null;
}

async function exchangeCodeForToken(code) {
  try {
    const { tokens } = await oauth2Client.getToken(code);
    saveRefreshToken(tokens);
    oauth2Client.setCredentials(tokens);
    return tokens;
  } catch (error) {
    console.error('Error exchanging code for token:', error.message);
    throw error;
  }
}

async function getAccessToken() {
  const tokens = loadRefreshToken();

  if (!tokens) {
    throw new Error('No refresh token found. Run initial authentication first.');
  }

  oauth2Client.setCredentials(tokens);

  if (oauth2Client.isTokenExpiring()) {
    console.log('Token expiring, refreshing...');
    const { credentials } = await oauth2Client.refreshAccessToken();
    saveRefreshToken(credentials);
    oauth2Client.setCredentials(credentials);
    return credentials.access_token;
  }

  return tokens.access_token;
}

module.exports = {
  oauth2Client,
  getAuthUrl,
  exchangeCodeForToken,
  getAccessToken,
  loadRefreshToken,
  saveRefreshToken
};

Now create server.js to set up the Express server and handle the OAuth callback:

const express = require('express');
const { getAuthUrl, exchangeCodeForToken, loadRefreshToken } = require('./auth');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;

app.get('/auth', (req, res) => {
  const authUrl = getAuthUrl();
  res.redirect(authUrl);
});

app.get('/oauth2callback', async (req, res) => {
  const code = req.query.code;

  if (!code) {
    return res.status(400).send('No authorization code received');
  }

  try {
    const tokens = await exchangeCodeForToken(code);
    res.send('Authorization successful! You can close this window and run your upload script.');
  } catch (error) {
    console.error('OAuth error:', error.message);
    res.status(500).send('Authorization failed: ' + error.message);
  }
});

app.get('/health', (req, res) => {
  const tokens = loadRefreshToken();
  if (tokens) {
    res.json({ status: 'authenticated', channelId: process.env.YOUTUBE_CHANNEL_ID });
  } else {
    res.json({ status: 'not_authenticated', authUrl: 'http://localhost:3000/auth' });
  }
});

app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
  console.log(`Visit http://localhost:${PORT}/auth to authenticate`);
});

Handling OAuth2 Token Refresh

Token refresh is critical. YouTube access tokens expire after one hour, but refresh tokens last much longer (until revoked). The oauth2Client.isTokenExpiring() check in auth.js handles this automatically, but let me show you a more robust approach for production:

Create tokenManager.js:

const fs = require('fs');
const { oauth2Client } = require('./auth');
require('dotenv').config();

const TOKEN_FILE = 'tokens.json';
const TOKEN_REFRESH_THRESHOLD = 300; // Refresh if expiring in next 5 minutes

class TokenManager {
  constructor() {
    this.tokens = this.loadTokens();
  }

  loadTokens() {
    if (fs.existsSync(TOKEN_FILE)) {
      return JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
    }
    return null;
  }

  saveTokens(tokens) {
    fs.writeFileSync(TOKEN_FILE, JSON.stringify(tokens, null, 2));
    this.tokens = tokens;
  }

  isExpiringSoon() {
    if (!this.tokens || !this.tokens.expiry_date) {
      return true;
    }
    const now = Date.now();
    const expiryTime = this.tokens.expiry_date;
    return (expiryTime - now) < (TOKEN_REFRESH_THRESHOLD * 1000);
  }

  async getValidAccessToken() {
    if (!this.tokens) {
      throw new Error('No tokens found. Authenticate first.');
    }

    oauth2Client.setCredentials(this.tokens);

    if (this.isExpiringSoon()) {
      console.log(`[${new Date().toISOString()}] Token expiring soon, refreshing...`);
      try {
        const { credentials } = await oauth2Client.refreshAccessToken();
        this.saveTokens(credentials);
        oauth2Client.setCredentials(credentials);
        console.log(`[${new Date().toISOString()}] Token refreshed successfully`);
        return credentials.access_token;
      } catch (error) {
        console.error('Token refresh failed:', error.message);
        throw error;
      }
    }

    return this.tokens.access_token;
  }
}

module.exports = new TokenManager();

Implementing Video Upload Logic

Now for the main event—uploading videos. Create uploader.js:

const { google } = require('googleapis');
const fs = require('fs');
const path = require('path');
const tokenManager = require('./tokenManager');
const { oauth2Client } = require('./auth');
require('dotenv').config();

const youtube = google.youtube('v3');

async function uploadVideo(videoFilePath, metadata) {
  try {
    const accessToken = await tokenManager.getValidAccessToken();
    oauth2Client.setCredentials({ access_token: accessToken });

    const fileName = path.basename(videoFilePath);
    const fileSize = fs.statSync(videoFilePath).size;

    console.log(`[${new Date().toISOString()}] Starting upload: ${fileName} (${fileSize} bytes)`);

    const response = await youtube.videos.insert(
      {
        part: 'snippet,status,processingDetails',
        requestBody: {
          snippet: {
            title: metadata.title || 'Untitled Video',
            description: metadata.description || '',
            tags: metadata.tags || [],
            categoryId: metadata.categoryId || '22',
            defaultLanguage: metadata.defaultLanguage || 'en',
            defaultAudioLanguage: metadata.defaultAudioLanguage || 'en'
          },
          status: {
            privacyStatus: metadata.privacyStatus || 'private',
            publishAt: metadata.publishAt || null,
            selfDeclaredMadeForKids: metadata.madeForKids || false
          }

Originally published on Automation Insider.

The Developer Guide to Choosing a Domain Registrar in 2026

Raizan — Mon, 04 May 2026 08:01:06 +0000

What You'll Need

Namecheap (or competitor registrars listed below)
A Hetzner VPS or Contabo VPS if you're planning to host automation workflows
n8n Cloud for workflow automation (optional, but pairs well with your domain)
10 minutes and a credit card

Why Domain Choice Actually Matters for Developers
The Core Registrar Features You Need
Top Registrars Ranked by Use Case
DNS Management: Where Automation Happens
Pricing Isn't Everything (But API Access Is)
Getting Started

Why Domain Choice Actually Matters for Developers

I used to think a domain registrar was just a domain registrar. Buy it somewhere cheap, move on. Then I started building automation workflows and realized—your registrar choice directly affects how quickly you can deploy, test, and manage infrastructure.

When you're setting up webhook endpoints, SSL certificates, or DNS records for a new staging environment, a clunky registrar dashboard costs you hours. When you need to automate DNS updates via API, a registrar without programmatic access becomes a bottleneck.

For developers in 2026, this choice matters as much as picking your hosting provider. In fact, it pairs directly with your infrastructure decisions. If you're deploying on a Hetzner VPS or Contabo VPS, your registrar needs to play nice with that environment through clean DNS delegation and API access.

The Core Registrar Features You Need

Before comparing specific platforms, let's define what actually matters:

1. DNS API Access — Can you programmatically manage DNS records? This is non-negotiable if you're automating anything. Most registrars offer REST APIs now, but the quality varies wildly.

2. Nameserver Flexibility — Can you point to custom nameservers without friction? This is essential for delegating to your VPS or a managed DNS provider.

3. WHOIS Privacy — Does it come included or cost extra? In 2026, this should be standard.

4. SSL Certificate Bundling — Are free or cheap SSL certs included? (They usually are, but verify.)

5. Bulk Operations — Can you manage 10+ domains efficiently, or does the UI require clicking through dialogs for each one?

6. Uptime and Support Quality — Registrars don't fail often, but when they do, support response time matters for critical projects.

7. Transfer Locks and Authorization — How straightforward is the process if you need to move domains later?

Top Registrars Ranked by Use Case

Best Overall for Developers: Namecheap

Namecheap remains my top recommendation. Here's why:

DNS API: Full REST API with clear documentation. You can automate ACME challenges for Let's Encrypt without thinking.
Price: Domains start around $8.88/year for .com (after promotional pricing). Renewal rates are honest, not inflated.
WHOIS Privacy: Included free with every domain.
Bulk Management: The dashboard handles 50+ domains without lag.
Uptime: Consistently reliable. No surprise nameserver outages in my 8+ years as a customer.

When to use Namecheap: You're building automation around your domains, need clean API access, and want predictable pricing.

When to skip it: If you need enterprise-grade white-label solutions (though they offer those too, at higher tiers).

Best for Cost-Conscious Builders: Google Domains

Google Domains offers competitive pricing and a clean UI, but—and I'll be direct—it's a good option only if you're not planning to automate. API access is limited compared to Namecheap. Google handles DNS management well for manual use, but if you're building workflows that touch your DNS layer, you'll hit walls.

When to use it: Personal projects, blogs, or sites where the domain is set-and-forget.

Best for Enterprise Scale: Route 53 (AWS)

If you're already deep in the AWS ecosystem and managing infrastructure through code, Route 53 is genuinely excellent. But—critical detail—you're not really "registering" through Route 53 in the traditional sense. You register with any registrar, then point to Route 53 for DNS management.

This is actually the model I recommend for serious automation projects. Buy cheap domains from Namecheap, then delegate DNS to Route 53. Separating registration from DNS gives you maximum flexibility.

When to use it: Infrastructure-as-code projects, CloudFormation templates, or teams already using AWS.

Best for European Compliance: EasyDNS or Gandi

If GDPR compliance or data residency is a requirement, EasyDNS (Canada-based) and Gandi (France-based) are stronger choices. They're transparent about data handling and offer EU-resident DNS servers.

When to use it: EU-based businesses or privacy-focused projects.

DNS Management: Where Automation Happens

Here's where the rubber meets the road. Once you own the domain, everything flows through DNS.

Let's say you're running an n8n Cloud instance and need to point a custom domain to it. You'll:

Create a CNAME record pointing your domain to the n8n endpoint
Verify DNS propagation
Configure SSL

With a good registrar's API, you can automate step 1 entirely. Here's what that looks like using Namecheap's API:

curl -X POST "https://api.namecheap.com/api/xml.response" \
  -d "ApiUser=YOUR_API_USER" \
  -d "ApiKey=YOUR_API_KEY" \
  -d "UserName=YOUR_USERNAME" \
  -d "Command=namecheap.domains.dns.setHosts" \
  -d "DomainName=example.com" \
  -d "TLD=com" \
  -d "SLD=example" \
  -d "HostName1=@" \
  -d "RecordType1=A" \
  -d "Address1=192.0.2.1" \
  -d "TTL1=1800" \
  -d "HostName2=www" \
  -d "RecordType2=CNAME" \
  -d "Address2=example.com" \
  -d "TTL2=1800"

This is the kind of operation that should take seconds, not manual clicks. A registrar without solid API support kills this workflow.

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

Pricing Isn't Everything (But API Access Is)

I see developers get lured by $0.99 domain promos and then regret it when renewal costs $18. Here's the reality in 2026:

First-year pricing is a lie. It's designed to lock you in. Look at year-two renewal rates.

Example comparison:

Namecheap .com: $8.88 first year (promo), $12.98 renewal
GoDaddy .com: $0.99 first year (promo), $15.99 renewal
Google Domains .com: $12.00 consistently

Over five years, Namecheap usually wins even with higher first-year costs because the renewal rate is predictable.

But here's what matters more: If your registrar doesn't have an API, you're paying a hidden cost in time and friction.

When you're spinning up staging environments or automating infrastructure, every extra manual step is expensive. That's why I recommend investing slightly more in a registrar with good API access rather than saving $2 per domain with a registrar that forces manual DNS management.

Getting Started

Here's your action plan:

1. Pick a registrar based on your use case:

Automation-heavy: Namecheap
AWS ecosystem: Route 53
EU compliance: EasyDNS or Gandi

2. If you're hosting automation workflows, pair your domain choice with proper infrastructure. Whether you're using a Hetzner VPS or Contabo VPS for your backend, point your domain's nameservers there and use your registrar's API for programmatic management.

3. Document your DNS setup in code. Whether it's Terraform, a shell script, or an n8n workflow, your DNS records should be reproducible.

4. Set up DNSSEC if your registrar supports it. It's a free security layer most developers skip.

5. Enable API access in your registrar's account immediately. Even if you don't need it today, you will soon.

If you're building anything serious—personal brand sites, automation infrastructure, or scalable projects—don't treat the registrar as a commodity purchase. Spend 20 minutes now evaluating registrar APIs. You'll save hours later.

Outsource Your Automation

Don't have time? I build production n8n workflows, WhatsApp bots, and fully automated YouTube Shorts pipelines. Hire me on Fiverr — mention SYS3-DEVTO for priority. Or DM at chasebot.online.

Originally published on Automation Insider.

Automating PDF Report Generation with n8n and Node.js

Raizan — Sun, 03 May 2026 08:00:28 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for hosting
Namecheap if domain needed
Node.js 16+ installed locally
A PDF generation library (we'll use PDFKit)
Basic knowledge of n8n workflows

The PDF Generation Challenge
Setting Up Your n8n Workflow
Building a Node.js PDF Service
Connecting n8n to Your PDF Generator
Real-World Example: Sales Report Automation
Getting Started

The PDF Generation Challenge

I've been automating workflows for three years now, and PDF generation is one of the most common requests I get. The challenge isn't just creating a PDF—it's doing it reliably, at scale, without manual intervention.

Most no-code platforms struggle with dynamic PDF creation because they lack granular control over styling, layout, and data injection. That's where combining n8n Cloud with a custom Node.js service becomes powerful. You get the orchestration power of n8n with the flexibility of server-side rendering.

Before we dive in, I should mention that if you're deciding between a cloud solution and self-hosting, the considerations differ when you're generating files. I've written about self-hosted n8n vs n8n Cloud before—self-hosted gives you full control over file storage and processing power, which matters for high-volume PDF generation.

Setting Up Your n8n Workflow

First, let's create the orchestration layer in n8n. I'm using n8n Cloud for this example, but the workflow translates directly to self-hosted instances.

Create a new workflow and start with a Webhook trigger:

{
  "nodes": [
    {
      "parameters": {
        "path": "generate-report",
        "httpMethod": "POST",
        "responseMode": "lastNode",
        "options": {}
      },
      "name": "Report Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 300]
    }
  ]
}

This webhook will accept POST requests with your report data. Next, add a function node to parse and validate incoming data:

const data = $input.all();
const reportRequest = data[0].json.body;

if (!reportRequest.companyName || !reportRequest.salesData || !reportRequest.period) {
  throw new Error('Missing required fields: companyName, salesData, period');
}

return [
  {
    json: {
      companyName: reportRequest.companyName,
      salesData: reportRequest.salesData,
      period: reportRequest.period,
      generatedAt: new Date().toISOString(),
      filename: `Report_${reportRequest.companyName}_${reportRequest.period}.pdf`
    }
  }
];

Now add an HTTP request node that will call your PDF generation service:

{
  "parameters": {
    "url": "http://your-pdf-service.local:3000/generate-pdf",
    "method": "POST",
    "headerParametersUi": {
      "parameter": [
        {
          "name": "Content-Type",
          "value": "application/json"
        }
      ]
    },
    "sendBody": true,
    "bodyParametersJson": "={{ $node[\"Parse Report Data\"].json }}"
  },
  "name": "Call PDF Generator",
  "type": "n8n-nodes-base.httpRequest",
  "typeVersion": 4,
  "position": [450, 300]
}

Building a Node.js PDF Service

Your Node.js service is where the actual PDF magic happens. I'm using Express and PDFKit for this—it gives you pixel-perfect control over layouts.

Create a new Node.js project:

mkdir pdf-generator-service
cd pdf-generator-service
npm init -y
npm install express pdfkit axios dotenv cors

Create your main server file:

const express = require('express');
const PDFDocument = require('pdfkit');
const fs = require('fs');
const path = require('path');
const cors = require('cors');
require('dotenv').config();

const app = express();
app.use(express.json());
app.use(cors());

const PDF_OUTPUT_DIR = path.join(__dirname, 'generated-pdfs');
if (!fs.existsSync(PDF_OUTPUT_DIR)) {
  fs.mkdirSync(PDF_OUTPUT_DIR, { recursive: true });
}

app.post('/generate-pdf', async (req, res) => {
  try {
    const { companyName, salesData, period, filename } = req.body;

    const pdfPath = path.join(PDF_OUTPUT_DIR, filename);
    const doc = new PDFDocument({
      size: 'A4',
      margin: 50,
      info: {
        Title: `Sales Report - ${period}`,
        Author: companyName,
        Subject: 'Automated Sales Report'
      }
    });

    const writeStream = fs.createWriteStream(pdfPath);
    doc.pipe(writeStream);

    doc.fontSize(24).font('Helvetica-Bold').text('SALES REPORT', { align: 'center' });
    doc.moveDown();
    doc.fontSize(12).font('Helvetica').text(`Company: ${companyName}`, { align: 'center' });
    doc.fontSize(12).text(`Period: ${period}`, { align: 'center' });
    doc.fontSize(10).text(`Generated: ${new Date().toLocaleString()}`, { align: 'center' });

    doc.moveTo(50, doc.y).lineTo(545, doc.y).stroke();
    doc.moveDown(1);

    doc.fontSize(14).font('Helvetica-Bold').text('Sales Summary', { underline: true });
    doc.moveDown(0.5);

    let totalRevenue = 0;
    let totalUnits = 0;

    if (Array.isArray(salesData) && salesData.length > 0) {
      const tableTop = doc.y + 20;
      const col1X = 70;
      const col2X = 250;
      const col3X = 400;
      const rowHeight = 25;

      doc.fontSize(11).font('Helvetica-Bold');
      doc.text('Product', col1X, tableTop);
      doc.text('Units Sold', col2X, tableTop);
      doc.text('Revenue', col3X, tableTop);

      doc.moveTo(50, tableTop + 15).lineTo(545, tableTop + 15).stroke();
      doc.font('Helvetica').fontSize(10);

      salesData.forEach((item, index) => {
        const rowY = tableTop + 20 + index * rowHeight;
        doc.text(item.product || 'N/A', col1X, rowY);
        doc.text(item.units || '0', col2X, rowY);
        doc.text(`$${item.revenue || 0}`, col3X, rowY);
        totalRevenue += item.revenue || 0;
        totalUnits += item.units || 0;
      });

      const summaryY = tableTop + 20 + salesData.length * rowHeight + 20;
      doc.moveTo(50, summaryY).lineTo(545, summaryY).stroke();
      doc.fontSize(11).font('Helvetica-Bold');
      doc.text('TOTALS', col1X, summaryY + 10);
      doc.text(totalUnits.toString(), col2X, summaryY + 10);
      doc.text(`$${totalRevenue.toFixed(2)}`, col3X, summaryY + 10);
    }

    doc.moveDown(3);
    doc.fontSize(10).font('Helvetica').text('This is an automatically generated report. No signature required.', {
      align: 'center',
      color: '#999999'
    });

    doc.end();

    writeStream.on('finish', () => {
      const fileBuffer = fs.readFileSync(pdfPath);
      res.setHeader('Content-Type', 'application/pdf');
      res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
      res.setHeader('Content-Length', fileBuffer.length);
      res.send(fileBuffer);

      fs.unlink(pdfPath, (err) => {
        if (err) console.error('Error deleting temp file:', err);
      });
    });

    writeStream.on('error', (err) => {
      console.error('Stream error:', err);
      res.status(500).json({ error: 'PDF generation failed', details: err.message });
    });

  } catch (error) {
    console.error('PDF generation error:', error);
    res.status(500).json({ error: 'PDF generation failed', details: error.message });
  }
});

app.get('/health', (req, res) => {
  res.json({ status: 'PDF service running', timestamp: new Date().toISOString() });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`PDF generation service listening on port ${PORT}`);
});

Create a .env file:

PORT=3000
NODE_ENV=development

Start the service:

node index.js

You should see: PDF generation service listening on port 3000

Connecting n8n to Your PDF Generator

Now let's complete the n8n workflow to handle the response and store your PDFs.

In your n8n workflow, add a node to save the PDF file. Add a Set node after your HTTP request:

const pdfBuffer = $input.all()[0].binary.data;
const filename = $input.all()[0].json.filename || 'report.pdf';

return [
  {
    json: {
      filename: filename,
      size: pdfBuffer.length,
      mimeType: 'application/pdf'
    },
    binary: {
      data: pdfBuffer
    }
  }
];

Next, add a Write Binary File node to persist the PDF:

{
  "parameters": {
    "fileName": "={{ $node[\"Set\"].json.filename }}",
    "dataPropertyName": "data",
    "options": {
      "outputFormat": "saveAs"
    }
  },
  "name": "Save PDF File",
  "type": "n8n-nodes-base.writeBinaryFile",
  "typeVersion": 1,
  "position": [650, 300]
}

If you're using self-hosted n8n, you might want to check out my guide on setting up Nginx as a reverse proxy with SSL so your webhook endpoint is secure when receiving sensitive report data.

Finally, add a response node to confirm success:

{
  "parameters": {
    "responseCode": 200,
    "options": {}
  },
  "name": "Return Success",
  "type": "n8n-

Originally published on Automation Insider.

Webhook Fundamentals: What They Are and How to Use Them

Raizan — Sat, 02 May 2026 08:00:41 +0000

What You'll Need

n8n Cloud or self-hosted n8n
Hetzner VPS or Contabo VPS for self-hosting
Namecheap if you need a custom domain
A code editor (VS Code recommended)
cURL or Postman for testing webhooks
Basic familiarity with JSON and HTTP requests

Understanding Webhooks: The Real-Time Solution
How Webhooks Actually Work
Setting Up Your First Webhook in n8n
Securing and Validating Webhooks
Common Webhook Patterns and Use Cases
Troubleshooting Webhook Issues
Getting Started

Understanding Webhooks: The Real-Time Solution

I've been automating workflows for years, and I can tell you that webhooks are the difference between clunky, scheduled integrations and truly responsive automation. Let me explain what's actually happening under the hood.

A webhook is an HTTP callback—essentially a way for one application to send real-time data to another application the moment something happens. Instead of your workflow constantly asking "did anything change yet?" (polling), a webhook is the source application saying "something just happened, here's the data."

Think of it like this: polling is checking your mailbox every hour. A webhook is the postman knocking on your door the moment mail arrives.

Why does this matter for automation? Speed. Reliability. Reduced API costs. If you're using n8n to replace expensive SaaS tools, webhooks cut your infrastructure costs dramatically because you're not hammering APIs with constant requests.

How Webhooks Actually Work

The webhook flow is straightforward but powerful:

Event triggers in the source application (a new Stripe payment, a form submission, a GitHub commit)
Source app sends HTTP POST request to your webhook URL with the event data
Your webhook receiver (n8n, your server, whatever) processes that data
Workflow executes based on the incoming data
Optional: Response sent back to the source application

The magic is that this all happens in milliseconds. No scheduled checks. No delays. Just instant reaction.

Here's what a typical webhook payload looks like:

{
  "event": "payment.completed",
  "timestamp": "2024-01-15T14:32:00Z",
  "data": {
    "payment_id": "pay_1234567890",
    "amount": 9999,
    "currency": "USD",
    "customer_id": "cus_9876543210",
    "status": "succeeded",
    "metadata": {
      "order_id": "ord_555",
      "customer_email": "user@example.com"
    }
  }
}

The source app doesn't care if your webhook succeeds or fails immediately—it just sends the data. That's why you need to build error handling into your workflow.

Setting Up Your First Webhook in n8n

I'm going to walk you through creating a production-ready webhook that captures data and processes it. I'll use n8n Cloud for this example, but the principles are identical for self-hosted.

Step 1: Create the Webhook Trigger

In n8n, add a new workflow and place a Webhook trigger node. Here's the configuration:

Click Add trigger → Webhook
Set HTTP Method to POST
Set Response Code to 200
Copy the Webhook URL (this is your public endpoint)

The URL will look like:

https://your-instance.n8n.cloud/webhook/unique-id-here

If you're self-hosting on Hetzner or Contabo, your URL might be:

https://automation.yourdomain.com/webhook/stripe-payments

Step 2: Parse the Incoming Data

Add a Set node to structure the webhook payload. Here's a real example that extracts Stripe payment data:

{
  "paymentId": "{{$json.data.payment_id}}",
  "amount": "{{$json.data.amount}}",
  "currency": "{{$json.data.currency}}",
  "customerId": "{{$json.data.customer_id}}",
  "status": "{{$json.data.status}}",
  "customerEmail": "{{$json.data.metadata.customer_email}}",
  "orderReference": "{{$json.data.metadata.order_id}}",
  "processedAt": "{{$now.toIso()}}"
}

This cleans up the raw webhook data into a standardized format your workflow can reliably work with.

Step 3: Route Based on Event Type

Add a Switch node to handle different webhook events:

Switch Node Expression:
$json.event

Conditions:
- payment.completed → Send to spreadsheet
- payment.failed → Send alert email
- charge.refunded → Log to database
- Default → Log to error handler

Step 4: Send Data to Your Destination

If you're storing payment data, you might send it to Google Sheets using n8n as a free database. Add a Google Sheets node:

Spreadsheet: "Payments"
Sheet: "All Transactions"
Options:
- Columns: paymentId, amount, currency, customerId, customerEmail, orderReference, status, processedAt
- Include Column Headers: true

Or if you need a proper database, use a Postgres node:

INSERT INTO payments (
  payment_id,
  amount,
  currency,
  customer_id,
  customer_email,
  order_reference,
  status,
  processed_at
) VALUES (
  $1, $2, $3, $4, $5, $6, $7, $8
)

Map your n8n variables to these placeholders.

Securing and Validating Webhooks

Here's where most people mess up: they treat webhooks like a public API endpoint. Don't do that. Anyone can send data to your webhook URL if they know it exists.

Implement Signature Verification

Most services (Stripe, GitHub, Slack) sign their webhooks with an HMAC signature. Here's how Stripe does it:

Stripe generates a timestamp
Stripe creates a signature using SHA-256 and your webhook secret
Stripe sends both in the Stripe-Signature header

In n8n, add a Code node to verify this before processing:

const crypto = require('crypto');

const signature = $request.headers['stripe-signature'];
const secret = 'whsec_your_webhook_secret';
const timestamp = signature.split(',')[0].split('=')[1];
const signedContent = `${timestamp}.${$json.body}`;

const expectedSignature = crypto
  .createHmac('sha256', secret)
  .update(signedContent)
  .digest('hex');

const receivedSignature = signature.split(',')[1].split('=')[1];

if (expectedSignature === receivedSignature) {
  return [{ valid: true }];
} else {
  return [{ valid: false, error: 'Invalid signature' }];
}

Add a Switch node after this:

If valid === true → continue processing
If valid === false → return 401 Unauthorized and stop

Use Webhook Secrets

In your webhook configuration, always set a secret. When you expose your webhook URL publicly, append a token:

https://automation.yourdomain.com/webhook/stripe-payments?secret=sk_live_abc123xyz789

Then in n8n's Webhook node, under Authentication, select your authentication method and validate this token before any processing happens.

Common Webhook Patterns and Use Cases

Pattern 1: Real-Time Form Processing

When someone submits a form on your website, immediately store data and send a confirmation email:

Website form → webhook trigger
Validate email format
Save to database or Google Sheets
Send confirmation email via SendGrid
Return 200 success

Pattern 2: Multi-Step Integrations

This is where webhooks shine. If you're automating social media posts with n8n, you could:

Webhook triggered by new blog post
Parse the post content
Generate social media snippets (via OpenAI API)
Post to Twitter, LinkedIn, Instagram
Log results to Airtable

Pattern 3: Error Handling and Retries

Webhooks can fail. Your server might be down. Add robustness:

const maxRetries = 3;
let attempts = 0;
let success = false;

while (attempts < maxRetries && !success) {
  try {
    attempts++;
    const response = await fetch('https://your-api.com/endpoint', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify($json)
    });
    if (response.ok) {
      success = true;
    }
  } catch (error) {
    if (attempts === maxRetries) {
      throw new Error(`Failed after ${maxRetries} attempts: ${error.message}`);
    }
    await new Promise(resolve => setTimeout(resolve, 1000 * attempts));
  }
}

return [{ success }];

Pattern 4: Batching Webhooks

If you receive thousands of webhooks per minute, batch them before processing:

Webhook received → store in Redis/Postgres with timestamp
Every 30 seconds, fetch all pending items
Process batch as single operation
Mark as processed

This reduces database load dramatically.

Troubleshooting Webhook Issues

Problem: Webhook not being called

Verify the URL is correct and publicly accessible
Check your firewall/security groups (port 443 for HTTPS)
Confirm the webhook is "enabled" in the source application
Test with cURL:

curl -X POST https://your-webhook-url \
  -H "Content-Type: application/json" \
  -d '{"test": "data"}'

Problem: Webhooks calling but n8n says "invalid"

Check the HTTP method matches (POST vs GET)
Verify authentication token is correct
Look at n8n's webhook logs for the exact error
Check if your firewall is blocking the request

Problem: Webhook times out

Your n8n workflow is taking too long. The source app will retry if you don't respond within a few seconds. Solution:

Acknowledge immediately: Return 200 as soon as webhook arrives
Process asynchronously: Use the Execute Workflow Trigger node to run heavy processing in the background

Problem: Duplicate webhook executions

Add a deduplication check using the webhook's unique ID:

const webhookId = $json.id;
const cached = $request.headers['x-cached'] === 'true';

if (cached) {
  return [{ duplicate: true, skipped: true }];
}

// Continue processing

Getting Started

Ready to implement webhooks in your automation? Here's your next step:

Sign up for n8n Cloud if you haven't already (

Originally published on Automation Insider.

How to Reduce Your SaaS Bill with Self-Hosted Alternatives

Raizan — Fri, 01 May 2026 08:00:26 +0000

What You'll Need

n8n Cloud or self-hosted n8n for workflow automation
Hetzner VPS or Contabo VPS for hosting your self-hosted stack
Namecheap if you need a custom domain for your applications
DigitalOcean as an alternative hosting option
Basic familiarity with Docker and command-line interfaces
Around 30 minutes to set up your first stack

The Real Cost of SaaS Bloat
Where Self-Hosted Wins
Building Your First Self-Hosted Stack
Migration Strategy: Moving Off Expensive Tools
Security and Maintenance
Getting Started

The Real Cost of SaaS Bloat

I used to have 14 active SaaS subscriptions. Slack at $8/user, GitHub at $4/user, Zapier for automation, Make for backup, text-to-speech services, image processing tools, video editing APIs—the list went on. At the end of every month, I'd watch roughly $2,400 disappear from my company's account.

The problem isn't that these tools are bad. They're excellent. But when you're running a small team or bootstrapped startup, that money could be reinvested in actual product development or hiring. I decided to audit which tools were actually worth their cost and which ones I could replace.

Here's what I discovered: about 70% of what I was paying for could be handled by self-hosted open-source alternatives running on a $10-30/month VPS. The remaining 30% were genuinely specialized services worth keeping (like Stripe for payments—there's no good self-hosted alternative).

This shift didn't happen overnight, but in 12 months, I cut my SaaS bill from $2,400 to under $400 monthly. More importantly, I gained complete control over my data and workflows.

Where Self-Hosted Wins

Not every SaaS should be replaced. But certain categories are ripe for disruption:

Workflow Automation: Tools like Zapier charge based on tasks or users. When you move to self-hosted n8n, you pay once for the server and can create unlimited workflows. If you're trying to decide between cloud and self-hosted, our detailed comparison of self-hosted n8n vs n8n Cloud breaks down exactly when each makes sense.

Media Processing: APIs for text-to-speech, video transcoding, and image manipulation are absurdly expensive at scale. I replaced multiple services with Edge TTS, which is completely free and requires no API keys. For video work, ffmpeg is a beast—command-line based but incredibly powerful once you learn the syntax.

Internal Tools: Databases, documentation systems, project management dashboards—these don't need the polish of SaaS alternatives when you're the only one using them.

Data Processing: ETL pipelines, data warehousing, and analytics. Self-hosted solutions let you avoid per-query or per-gigabyte pricing.

Email Infrastructure: Postfix + Dovecot are ancient but rock-solid for managing your own mail server, though this one requires the most operational attention.

Building Your First Self-Hosted Stack

Let me walk you through setting up a practical stack that handles workflow automation, text-to-speech, and basic media processing on a single VPS.

Step 1: Choose and Configure Your VPS

I recommend Hetzner VPS for cost-effectiveness or Contabo VPS if you want more storage. For most workflows, a 4-core/8GB RAM instance is sufficient. Here's what I deploy:

#!/bin/bash
# Run this as root after SSH into your fresh VPS

# Update system packages
apt update && apt upgrade -y

# Install Docker
apt install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
apt install -y docker-ce docker-ce-cli containerd.io

# Install Docker Compose
curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# Create app directory
mkdir -p /opt/selfhosted
cd /opt/selfhosted

# Install Nginx as reverse proxy
apt install -y nginx

# Create Nginx config directory
mkdir -p /etc/nginx/sites-available

Step 2: Deploy n8n for Automation

n8n is where the magic happens. Create a docker-compose.yml:

version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    environment:
      - N8N_HOST=workflow.yourdomain.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - GENERIC_TIMEZONE=UTC
      - DB_TYPE=postgres
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=your_secure_password_here
      - N8N_SECURE_COOKIE=true
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres
    networks:
      - n8n_network
    restart: unless-stopped

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

volumes:
  n8n_data:
  postgres_data:

networks:
  n8n_network:
    driver: bridge

Start the stack:

cd /opt/selfhosted
docker-compose up -d

Step 3: Add Text-to-Speech and Media Processing

Create a separate service for media utilities. Since we're handling text-to-speech, here's a simple Express app that wraps Edge TTS:

cd /opt/selfhosted
mkdir -p tts-service
cd tts-service

Create package.json:

{
  "name": "tts-service",
  "version": "1.0.0",
  "description": "Self-hosted TTS and media service",
  "main": "server.js",
  "dependencies": {
    "express": "^4.18.2",
    "edge-tts": "^0.3.0",
    "fluent-ffmpeg": "^2.1.2",
    "multer": "^1.4.5-lts.1",
    "dotenv": "^16.3.1"
  },
  "scripts": {
    "start": "node server.js"
  }
}

Create server.js:

const express = require('express');
const { execFile } = require('child_process');
const path = require('path');
const fs = require('fs');

const app = express();
const PORT = 3000;

app.use(express.json());

// TTS endpoint
app.post('/tts', async (req, res) => {
  const { text, voice, outputFormat } = req.body;

  if (!text) {
    return res.status(400).json({ error: 'Text is required' });
  }

  const voiceChoice = voice || 'en-US-AriaNeural';
  const format = outputFormat || 'mp3';
  const outputFile = path.join('/tmp', `tts_${Date.now()}.${format}`);

  try {
    execFile('edge-tts', [
      '--text', text,
      '--voice', voiceChoice,
      '--write-media', outputFile
    ], (error, stdout, stderr) => {
      if (error) {
        console.error('TTS Error:', error);
        return res.status(500).json({ error: 'TTS generation failed' });
      }

      res.download(outputFile, `output.${format}`, (err) => {
        if (err) console.error('Download error:', err);
        fs.unlink(outputFile, (unlinkErr) => {
          if (unlinkErr) console.error('Cleanup error:', unlinkErr);
        });
      });
    });
  } catch (err) {
    console.error('Error:', err);
    res.status(500).json({ error: 'Server error' });
  }
});

// Health check
app.get('/health', (req, res) => {
  res.json({ status: 'healthy' });
});

app.listen(PORT, () => {
  console.log(`TTS Service running on port ${PORT}`);
});

Create a Dockerfile:

FROM node:18-alpine

RUN apk add --no-cache \
    python3 \
    ffmpeg \
    curl \
    git

WORKDIR /app

COPY package.json package-lock.json ./
RUN npm install

RUN pip install edge-tts

COPY server.js .

EXPOSE 3000

CMD ["npm", "start"]

Add this service to your docker-compose.yml:

  tts-service:
    build: ./tts-service
    container_name: tts_service
    ports:
      - "3000:3000"
    networks:
      - n8n_network
    restart: unless-stopped
    environment:
      - NODE_ENV=production

Rebuild and restart:

docker-compose up -d --build

Step 4: Set Up Nginx Reverse Proxy

Create /etc/nginx/sites-available/selfhosted.conf:

upstream n8n {
    server localhost:5678;
}

upstream tts {
    server localhost:3000;
}

server {
    listen 80;
    server_name workflow.yourdomain.com tts.yourdomain.com;

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    server_name workflow.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/workflow.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/workflow.yourdomain.com/privkey.pem;

    ssl_protocols TLSv1.2 T

Originally published on Automation Insider.

DEV Community: Raizan

Temporal vs Make for API-First Workflows

What You'll Need

Table of Contents

What's the Real Difference Between Temporal and Make?

Temporal: The Orchestration Engine Approach

Setting Up Temporal Locally

Make: The Visual No-Code Platform

Make vs n8n vs Zapier API integrations 2026

What You'll Need

Table of Contents

The 2026 Automation Landscape

n8n API Integration Strategy

Make.com's Native Connectors vs Custom APIs

Zapier's Webhook-First Approach

Temporal vs n8n for Microservices Orchestration

What You'll Need

Table of Contents

What is Temporal?

What is n8n?

Architecture Comparison

Building a Microservice Workflow with Temporal

Building the Same Workflow with n8n

Building Custom Webhooks vs Using n8n Triggers

What You'll Need

Table of Contents

Understanding Webhooks and Triggers

When to Build Custom Webhooks

Building a Custom Webhook Server

Using n8n Triggers: The Simpler Path

Performance and Cost Comparison

How I Run 3 Automated Systems on a Single $7/Month VPS

What You'll Need

Table of Contents

The Reality of Running Multiple Systems on Minimal Infrastructure {#reality}

System 1: Lead Capture to CRM Pipeline {#system-1-lead-capture}

Setting Up n8n on Your VPS

The Lead Workflow

Cron Jobs Explained: Scheduling Automated Tasks on Linux

What You'll Need

Table of Contents

Understanding Cron: The Basics

Crontab Syntax Breakdown

Creating and Managing Your First Cron Job

Real-World Examples and Use Cases

Debugging and Monitoring Cron Jobs

SQLite vs PostgreSQL for Small Projects: When to Use Which

What You'll Need

Table of Contents

Understanding the Fundamentals

SQLite: Lightweight and Local

PostgreSQL: Scalable and Powerful

Head-to-Head Comparison

Migration Strategies

How to Build a YouTube Upload Bot with Node.js and OAuth2

What You'll Need

Table of Contents

Understanding the YouTube Upload Workflow

Setting Up Google OAuth2 Credentials

Building the Core Node.js Bot

Handling OAuth2 Token Refresh

Implementing Video Upload Logic

The Developer Guide to Choosing a Domain Registrar in 2026

What You'll Need

Table of Contents

Why Domain Choice Actually Matters for Developers

The Core Registrar Features You Need

Top Registrars Ranked by Use Case

Best Overall for Developers: Namecheap

Best for Cost-Conscious Builders: Google Domains

Best for Enterprise Scale: Route 53 (AWS)

Best for European Compliance: EasyDNS or Gandi

DNS Management: Where Automation Happens

Pricing Isn't Everything (But API Access Is)

Getting Started

Outsource Your Automation

Automating PDF Report Generation with n8n and Node.js

What You'll Need

Table of Contents

The PDF Generation Challenge