n8n vs Zapier vs Make vs custom code: choosing an automation stack

Almost every growing business reaches the same point: leads are copied from forms into a CRM by hand, invoices are chased from a spreadsheet, and someone spends Friday afternoon assembling a report. Automation is clearly the answer. The question is which tool, and the honest answer is that Zapier, Make, n8n and custom code are each the right choice for somebody.

The wrong choice is rarely catastrophic on day one. It shows up a year later, as a bill that scales with every record processed, a tangle of flows nobody understands, or a custom service that only one engineer can change. This guide compares the options on the criteria that matter over that longer horizon.

Zapier: fastest path for simple flows

Zapier's strength is breadth and simplicity. It has one of the largest catalogues of app integrations, and a non-technical person can build a trigger-and-action flow in minutes. For linear automations, such as a new form submission creating a CRM contact and posting to Slack, it is hard to beat for speed.

Pricing is based on tasks, roughly each action step that runs, on tiered plans. That is great at low volume and becomes a real consideration as volume grows or flows gain more steps. Complex branching, loops and heavy data transformation are possible but get awkward compared to tools designed around them. Zapier is fully hosted, so your data passes through its infrastructure.

Make: visual power for complex scenarios

Make (formerly Integromat) uses a visual canvas where data flows between modules. It handles branching, iterators, aggregators and data mapping more naturally than Zapier, which makes it a good fit for multi-step processes with real logic, built by technically minded operations people.

Billing is usage-based, counting each module execution as a unit of consumption, so cost depends on both volume and how many steps each run takes. That model rewards efficient scenario design, such as filtering early and avoiding unnecessary iterations. Like Zapier, Make is a hosted service.

n8n: open, self-hostable and developer-friendly

n8n is a workflow tool with a visual editor that developers tend to like: you can drop into JavaScript or Python in code nodes, call any HTTP API, and build AI agent workflows with model, memory and tool nodes. Its source is available under a fair-code licence, and you can self-host it, which means data stays in your infrastructure and there is no per-execution charge from n8n itself. There is also a managed cloud version billed by workflow executions, and enterprise plans.

Self-hosting trades subscription cost for operational responsibility: you own upgrades, backups, credentials security, scaling with queue mode and monitoring. Read the licence terms if you plan to embed n8n in a product you sell. A minimal self-hosted setup looks like this:

services:
  n8n:
    image: docker.n8n.io/n8nio/n8n:latest # pin a specific version in production
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=automations.example.com
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://automations.example.com/
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - GENERIC_TIMEZONE=Europe/London
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres

  postgres:
    image: postgres:16
    restart: unless-stopped
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    volumes:
      - pg_data:/var/lib/postgresql/data

volumes:
  n8n_data:
  pg_data:

Custom code: full control, full responsibility

Writing the automation as a regular service, for example a Node.js or Python worker with a queue, gives you everything the platforms abstract away: version control, code review, automated tests, typed data, proper retries and idempotency, and no per-run fees. It is the right choice when the automation is the product, when volume is high, when logic is genuinely complex, or when compliance requires tight control over data.

The cost is that every integration is code you write and maintain: authentication, pagination, rate limits and API changes. Non-technical staff can no longer tweak a flow themselves. For a lead-routing flow that changes monthly at the request of the sales team, that is a real loss.

How to choose

• Owner: if operations or marketing will build and change flows, start with Zapier or Make. If engineers own them, n8n or code.
• Volume and steps: per-task and per-operation billing is ideal at low volume. At high or spiky volume, model your costs; self-hosted n8n or code often wins.
• Logic: linear flows suit Zapier. Branching and data transformation suit Make or n8n. Complex state, long-running processes and heavy testing needs point to code.
• Data and compliance: if data must stay in your infrastructure or region, self-hosted n8n or custom code are the realistic options.
• AI steps: all of them can call model APIs. n8n and code make it easier to build agent loops, add validation and control prompts and costs precisely.

Mixed stacks are common and healthy. A sensible pattern is no-code for the long tail of simple internal flows, and code or n8n for the few business-critical pipelines where reliability, cost and testing matter most. Whatever you choose, keep an inventory of automations with an owner for each, alert on failures and store credentials centrally. Unowned automations that silently stop working are a bigger risk than the choice of tool.

Finally, plan for change. Whichever tool you start with, document each flow's trigger, steps and business rules in plain language outside the tool. That document is what makes it possible to move a flow from Zapier to n8n, or from n8n to code, when its volume or importance grows, without rediscovering the logic by clicking through a canvas.

Key takeaways

• Zapier is fastest for simple, linear flows built by non-developers; billing scales with tasks.
• Make suits visually built, logic-heavy scenarios; billing scales with operations per run.
• n8n offers code nodes, AI workflows and self-hosting, trading subscription fees for operational work.
• Custom code gives full control, testing and low marginal cost, at the price of engineering ownership.
• Choose by owner, volume, logic complexity and data requirements, and expect a mixed stack over time.

Need help choosing or migrating between platforms? Our AI automations team builds on all of these, plus custom code. Contact us to map out your workflows.