Kestra vs Make

At a Glance

Kestra and Make both sit in the workflow automation category, both are EU-built, and both appear when a team decides Zapier is not the answer. The resemblance stops at the category label. Kestra orchestrates jobs that run on infrastructure you operate; Make moves records between SaaS accounts you already pay for.

So the useful question is not which platform is more powerful. It is which job title will own the automation a year after it ships — a data or platform engineer, or somebody in operations, marketing, or finance.

What Each Platform Actually Automates

A Kestra workflow is a set of tasks that execute somewhere you control: a Python script, a Bash command, a dbt transformation, a Terraform plan, a containerised job. The 1,900-plugin catalogue reflects that emphasis, covering AWS, Google Cloud, Azure, Snowflake, Databricks, Airbyte, dbt, Terraform, and Mistral. Kestra is the layer deciding what runs, in what order, and what happens when a step fails.

A Make scenario is a chain of modules, and each module is an authenticated action inside somebody else's product. Create a HubSpot deal. Append a row in Google Sheets. Post to Slack, then raise a Stripe invoice. Nothing executes on your servers — Make holds the credentials, calls the APIs, and passes data between them.

There is genuine overlap. Both react to webhooks, both call arbitrary REST endpoints, and both talk to large language models — Make through native OpenAI, Claude, and Gemini modules, Kestra through AI plugins and its workflow Copilot. But overlap at the edges does not make two tools substitutes at the centre.

Edge: Kestra for pipelines that execute code your team wrote. Make for processes that stitch together products your team subscribes to.

Who Builds It, and Who Maintains It

This is the axis that decides most evaluations.

Kestra workflows are YAML documents. They live in Git, deploy through the same CI/CD pipeline as application code, and get reviewed in pull requests by people who read declarative config for a living. A reviewer can see what a pipeline does without tracing Python control flow, which is precisely the argument Kestra makes against Airflow's DAG model. The cost of that model is a prerequisite: somebody on the team has to be comfortable writing and reviewing structured config. Python-native teams may still prefer the decorator-based API that Prefect offers.

Make scenarios are drawn, not written. An operations manager can build a working scenario on the canvas without a repository, a deployment pipeline, or an engineer's calendar time. Maia, Make's AI assistant, generates a first draft of a scenario from a natural-language description, which shortens the blank-canvas problem further. Both products rate 7.0 for ease of use in our scoring. The identical number hides two different learning curves: Kestra asks you to learn a config format, while Make asks you to learn a visual execution model deliberately richer than Zapier's trigger-action steps.

Governance follows authorship. On Kestra, change control is the pull request, with role-based access control, audit logs, and workflow versioning as core primitives. With Make, change control is a product feature: team roles and shared templates arrive on the Teams plan at $34.12 per month, and SSO sits behind Enterprise.

Edge: Kestra where automation has to pass code review. Make where the person with the business problem should also be the person who solves it.

Two Catalogues Pointing in Opposite Directions

Headline numbers invite a false comparison: Make lists more than 3,000 app integrations, Kestra more than 1,900 plugins. Those totals count different kinds of endpoint, so the larger figure means very little on its own.

Make's library maps the SaaS economy: Google Workspace, Microsoft 365, Slack, HubSpot, Salesforce, Shopify, Airtable, Notion, Stripe. Its known weak spot is the long tail — niche, industry-specific tools that Zapier carries and Make does not.

Kestra's library maps the data and infrastructure stack: warehouses, transformation tools, cloud providers, container platforms, messaging, and model providers. Its known weak spot is maturity, since Apache Airflow has a decade-long head start and a much larger contributor base.

Both keep an escape hatch. Make ships HTTP and webhook modules that reach any REST API; Kestra is API-first, with webhook, message-queue, and file-based triggers. In both cases that escape hatch costs technical effort the pre-built catalogue does not.

Edge: Kestra for the data and infrastructure endpoints Make's catalogue barely touches. Make for breadth across business software.

Failure Handling and Debugging

Kestra treats reliability as configuration. Retries, timeouts, and SLAs are declared per task, alongside audit logs and versioned flow history. The assumption behind that design is an engineering team with an alerting stack already in place — Kestra reports the failure, and your existing on-call process handles it. Support on the free tier runs through community Slack and GitHub, and an SLA-backed response requires Enterprise Edition, which is why support scores 6.5 in our ratings.

Make treats debugging as an interface. Execution history lets you click any module in a finished run and inspect exactly what data entered and left it. Scenario Run Replay re-runs a scenario against historical trigger data, so an edge case gets fixed without waiting for it to recur. Error handlers define fallback routes when a module fails, and they are available on every plan, including Free.

The real distinction is who is expected to be looking. Kestra assumes a platform team watching dashboards; Make assumes the person who built the scenario will open it, see the red module, and fix it.

Edge: Kestra for pipelines carrying an SLA. Make for repairs that should never need a ticket.

Cost Structure and Predictability

Kestra's open-source core is free, with unlimited flows and unlimited executions, self-hosted on Docker, Kubernetes, or a single VM. No ceiling pushes you toward a paid tier, so the real bill is infrastructure plus the operational attention of running an orchestrator. Kestra Cloud is usage-based and Enterprise Edition is a per-instance annual licence, but neither price is published. Both require a sales conversation, which is real friction for a team trying to budget in advance.

Make publishes everything, in US dollars. Free covers 1,000 credits a month with a 15-minute minimum interval. Core is $10.59 per month for 10,000 credits, Pro is $18.82, and Teams is $34.12; those are annual-billing rates, and monthly billing runs roughly 30% higher. Enterprise pricing is custom and adds overage protection.

Credits are the catch worth understanding. Every module action consumes credits, so cost tracks workflow complexity rather than workflow count, and scenarios heavy in loops and iterators can spend unpredictably. Unused credits on paid plans roll over for one month, which takes some sting out of a quiet quarter.

Edge: Kestra at high execution volume, where an extra run costs nothing but compute. Make for teams that want a number they can approve without booking a call.

EU Jurisdiction and Data Handling

Kestra Technologies is registered in La Madeleine, near Lille, which places the company under French and EU jurisdiction. The self-hosted architecture answers the residency question by construction: workflow data, credentials, and execution logs never leave infrastructure the customer controls. Air-gapped deployment is supported for networks with no public internet access at all. Kestra Cloud is SOC 2 compliant for teams that would rather not operate the platform themselves, and our EU compliance rating for Kestra is 8.0.

Make is headquartered in Prague and owned by Celonis SE of Munich — an EU company with an EU parent. It holds ISO 27001 certification, has completed SOC 2 Type II and SOC 3 audits, encrypts traffic with TLS 1.2/1.3 and AES 256, and hosts data in the EU. That certification stack earns 8.5 for EU compliance, half a point ahead of Kestra. One caveat carries over from our review: Make connects to third-party services, so the GDPR posture of a finished scenario depends on every service in the chain, not on Make alone.

Edge: Kestra for absolute residency control. Make for audit-ready certifications on day one.

When to Choose Kestra

Choose Kestra when the automation is engineering work. Data pipelines feeding a warehouse, model training and retrieval workflows, Terraform runs, Kubernetes jobs — anything whose unit of work is code your team maintains — belongs in an orchestrator rather than an iPaaS. Kestra's declarative model keeps those pipelines reviewable in Git instead of trapped in a canvas only one person understands.

It is also the right answer under two specific constraints. High execution volume makes per-action billing painful, and the unrestricted open-source core removes that ceiling entirely. Strict data residency rules make hosted-only tools awkward, and self-hosting settles the question without a procurement argument.

Pick Kestra if your automation runs code, carries an SLA, and belongs to a platform or data team.

When to Choose Make

Choose Make when the automation is business process. Lead routing, order fulfilment, invoice chasing, content pipelines spanning a dozen SaaS products — work whose difficulty is integration breadth rather than execution semantics — is exactly what a visual iPaaS handles well.

Make also wins on time-to-first-automation. A working scenario can exist the same afternoon, built by the person who understands the process, with no repository to set up and no infrastructure to provision. For agencies running automations across many clients, and for operations teams without engineering support on tap, that speed is the whole argument. Published pricing starting at $10.59 a month makes the spend easy to approve.

Teams that want the visual model but occasionally need to drop into code should also weigh n8n, which we put head-to-head with Make in a separate comparison.

Pick Make if your automation connects products you buy, and the people closest to the process should own it.

The Verdict

Kestra and Make are not really competitors; they are answers to different questions that happen to share a category page. Orchestration is Kestra's job: scheduling, retrying, and governing code that runs on your own infrastructure. Integration is Make's: carrying data between SaaS products through a canvas a non-engineer can maintain.

Kestra is the stronger choice for data and platform engineering teams. The unrestricted open-source core, a plugin catalogue spanning cloud and data tooling, and Git-native authoring give it a governance story no visual builder matches. Its trade-offs are equally clear: a younger ecosystem than Airflow's, community-only support at the free tier, and unpublished pricing above it.

Make is the stronger choice for operations, marketing, and agency teams. It is the most capable visual automation platform Europe has produced, its pricing is transparent, and its compliance certifications are already enterprise-grade. The trade-offs are real too — credit-based billing that scales with complexity, a canvas steeper than Zapier's, and no self-hosted option at any price.

If the automation touches a data warehouse, a container runtime, or a Terraform state file, the answer is Kestra. When it touches a CRM, a store, and a mailbox, the answer is Make. Teams that end up running both are not doing anything strange, because the two tools automate different halves of the same company.