n8n vs. Make vs. custom: when to use what

Automation is no longer a luxury—it's expected. But the moment you need to wire together your operations, you face a choice that feels overwhelming: build something custom, use a visual no-code tool, or go somewhere in between?

The honest answer: there's no universal winner. What works for a 5-person marketing team looks completely different from what a data engineering department needs. The real question isn't "which is best," but "which is right for my constraints?"

Let's break down the three main paths, their real limitations, and when each one actually makes sense.

Make: visual, accessible, expensive at scale

Make (formerly Integromat) is where most teams start. It's a visual workflow builder that feels intuitive—you click together modules, map fields, and suddenly your Slack connects to your Notion database. It works. And for many teams, it's exactly what they need.

Best for:

• Non-technical teams who need to ship automation quickly
• Visual workflows with clear input-to-output paths
• SaaS integrations—Make has hundreds of pre-built connectors
• Marketing, operations, and HR teams automating routine tasks

Real limitations:

• Pricing scales with operations. Each execution costs money. At volume, this becomes expensive fast. A 10,000-operation workflow might run $200-400/month depending on your plan.
• Complex logic gets messy. Branching, error handling, and conditional flows become hard to visualize and debug when your workflow has 50 steps.
• Vendor lock-in. Your automation lives in Make's platform. Want to migrate? You're rewriting everything.
• Limited data transformation. Need to transform JSON deeply or do statistical calculations? You'll hit the ceiling quickly.

Sweet spot: Marketing teams handling Typeform leads → Slack notifications → CRM updates. Social media pipelines. Simple CRM automations where the workflow is linear and execution volume is under 5,000/month.

n8n: self-hosted, technical, full control

n8n is the bridge. It has a visual builder like Make, but you can host it yourself. It's open-source. You can write custom JavaScript. It's built for teams that want flexibility without writing everything from scratch.

Best for:

• Technical teams comfortable with self-hosting and infrastructure
• Data-heavy workflows that need custom transformations
• Internal tools where speed matters more than polish
• Teams with cost-sensitive operations running high volume

Real limitations:

• Steeper learning curve. You need to understand node architecture, debugging, and how the platform handles errors. Not a weekend project for non-technical users.
• Hosting and maintenance. You're responsible for the server, updates, scaling, backups. This is DevOps work.
• Community vs. enterprise trade-off. The free/community version is powerful, but if you need enterprise features (SSO, audit logs), pricing jumps significantly.
• Smaller ecosystem of pre-built integrations. Many SaaS tools don't have official n8n nodes, so you're building REST API calls yourself.

Sweet spot: Dev teams building data pipelines. Internal automation where you control the entire stack. Anything running more than 50,000 operations/month where cost per operation matters. Companies with existing infrastructure who can add n8n to their own deployment.

Custom-built: full power, full responsibility

Sometimes the right answer is Python. Or Node. Or a serverless function on AWS Lambda. Custom code doesn't care about platform limitations—it does exactly what you need.

Best for:

• Complex business logic that doesn't fit visual workflows
• High-volume operations where cost per execution matters and performance is critical
• AI and ML integration. Want to call your custom ML model as part of the automation? Custom code is the only real option.
• Tight integrations with existing systems where generic connectors don't cut it
• Mission-critical processes where you need complete control over error handling and recovery

Real limitations:

• Development cost upfront. You need engineers. It takes time. A simple workflow might take a week to build properly.
• Maintenance burden. Every library update, every API change from your vendors, every scaling decision lands on your team.
• Requires engineering culture. Custom code needs testing, monitoring, logging, and documentation. If you don't have that, you'll pay for it later with bugs.
• Knowledge concentration. The person who wrote it knows how it works. If they leave, you have technical debt.

Sweet spot: Core business processes that generate value directly. Data warehousing pipelines. Anything involving AI—embedding API calls, LLM routing, or ML model inference. High-scale operations running millions of transactions. Any workflow that's mission-critical to your business.

The decision framework

The hybrid approach

Here's the thing most teams don't consider: you don't have to pick one. The best automation stacks use all three.

A typical setup might look like: Make handles your simple marketing workflows (cheap, fast to ship). n8n handles your data transformations and internal tools (flexible, under your control). Custom Python scripts handle your ML inference and core business logic (powerful, isolated from platform changes).

This isn't more complex—it's actually simpler. Each tool does what it's good at. You use Make's 200 pre-built connectors for SaaS glue. You use n8n's visual builder and custom JS for the middle layer. You use Python for the hard stuff.

What actually matters

The real cost isn't the tool. It's the operations cost (Make's pricing) or the engineering time (custom code) or the infrastructure burden (n8n). You're trading off speed, cost, and control. Pick which one matters most for this specific workflow, then choose your tool.

And if you're not sure? Start with Make. It's the lowest-risk entry point. Once you hit its limits—and you will—you'll know exactly what you need next.