The feature comparison is a distraction
Any of these platforms can move data between two systems on a trigger. Comparing connector counts is close to meaningless, because the connector you need either exists or you are calling an HTTP endpoint yourself, and every one of them can call an HTTP endpoint.
The decisions that actually matter show up months later: what it costs as volume grows, how quickly you can tell why a run failed, and whether the person who inherits it can work on it.
Cost scales differently, and the difference compounds
These platforms bill on different units. Some count each step in a workflow, some count each run regardless of steps, some are a flat cost for a server you operate. A workflow with many small steps is cheap under one model and expensive under another, and the ranking flips depending on the shape of your automation rather than its usefulness.
The practical move is to take one real workflow you already run, count its steps and its monthly volume, and price it under each model. This takes twenty minutes and is far more informative than any comparison table, because it uses your shape rather than an average one.
Watch for the cliff: pricing tiers tend to jump rather than glide, so the meaningful question is not what it costs now but what it costs at three times the volume.
Debuggability is the property you will care about most
Six months in, the question is never "can this platform do X". It is "why did last Tuesday's run not fire". What you want to know is which step failed, what the input to that step was, what came back, and whether it was retried.
Look specifically for: how long execution history is retained, whether you can see the actual payload at each step, whether you can replay a failed run with the original input, and whether failures notify anyone or simply sit in a log. Retention is the one people are most often surprised by, because it is short on the cheaper tiers and you only discover that while investigating something that happened last week.
Self-hosting trades a bill for a responsibility
Running your own instance removes per-run pricing and gives you full access to execution data. It also makes you responsible for uptime, upgrades, backups, and the credentials stored inside it.
That trade is worth making when automation volume is high enough that per-run pricing dominates, or when the data passing through genuinely cannot leave your own infrastructure. It is not worth making to save a small subscription, because the operational cost of a server nobody is watching is much higher than the invoice.
- High volume, predictable shape: self-hosting usually wins
- Sensitive data with residency requirements: self-hosting is often the only option
- A handful of workflows, low volume: hosted is almost always cheaper in total
- Nobody on hand to own a server: hosted, without hesitation
Ask who maintains it, and design for that answer
If the answer is a non-technical operations person, a visual builder with a constrained node set is a feature, not a limitation — the constraint is what keeps the workflow readable. If the answer is a developer, the ability to drop into code inside a step will save a great deal of contorted node-wiring.
Choosing a tool that assumes the wrong maintainer produces the same outcome either way: the workflow stops being edited, then stops being trusted, then gets replaced by a person doing it manually again.
Assume you will move at least once
Treat the platform as replaceable. Keep the business rules written down outside it, keep credentials in one place you control, and prefer plain HTTP calls to proprietary steps where the difference is small.
None of that is free, but it is much cheaper than discovering that a year of process knowledge exists only as boxes and arrows inside a product you have outgrown.
Test the integration you are actually worried about
Every platform's connector list includes the tool you need. What the list does not tell you is whether that connector supports the specific operation you depend on, at the volume you need, with the fields you care about.
Before committing, build the single riskiest step — the unusual API, the high-volume sync, the one with awkward pagination — on a trial account. An afternoon spent here answers a question no comparison article can, because the answer depends on your endpoint rather than on the platform in general.
Credentials and access are a security decision
These platforms hold long-lived credentials to your business systems. That makes the platform part of your security surface, and worth the same questions you would ask of any vendor with that access.
Who on your team can see or export stored credentials. Whether connections are made under a service account or a person's login — the latter breaks when they leave, and takes the workflow with it. Whether audit history shows who changed a workflow and when. Whether data passing through is retained, and for how long.
- Connect under service accounts, never a personal login
- Keep an inventory of which workflows hold which credentials
- Know the retention period for execution data containing customer information
- Confirm you can revoke access quickly if you need to
Plan the exit before you need it
Treat the platform as replaceable, because eventually it will be. Keep the business rules written down outside it, keep credentials in one place you control, and prefer plain HTTP calls to proprietary steps where the difference is small.
Exports help less than people expect: most platforms export a workflow in their own format, which is useful for backup and useless for migration. The portable artifact is the written description of what the process does and why.
The honest summary
For a handful of straightforward workflows maintained by a non-technical team, the hosted options are almost always right and the choice between them is close to arbitrary. For high volume, unusual integrations, or data that cannot leave your infrastructure, self-hosting starts to pay — provided somebody owns the server.
The wrong answer is choosing on a feature matrix and discovering the real constraints six months later.