Zapier and Make Charge for Logic Steps. That's the Hidden Tax.

When you add a Filter step to a Zapier workflow, you're charged for it. Not for anything the filter does, just for running. The filter checks the incoming data, decides your condition isn't met, stops the workflow before any action fires, and Zapier counts that as a task. You paid for the automation to decide it shouldn't do anything.

That's how per-task pricing works. Every step that executes is a task, whether it's an AI call that drafts an email, an API request that updates your CRM, or a router that evaluates a condition and picks a path. The infrastructure that makes your workflow smart costs the same as the actions that make it useful.

Most people don't notice until they build something more complex than a two-step zap.

What the bill actually reflects

Take a typical lead qualification workflow: an email arrives, a filter checks whether it's from a business domain, a classification step determines the lead tier, a CRM record gets created, and a reply draft gets queued. Five steps. Run it a thousand times a month on Zapier's Growth plan, and you're looking at 5,000 tasks even though two of those steps are pure logic that never touch an external system.

Add a Paths step to route enterprise leads to a different CRM pipeline than SMB leads, and you're potentially charged for each path evaluated, not just the one taken. Add a Formatter step to standardize the company name field before it writes to your CRM, and that's another task per run.

Make uses the same model under a different name. They call them "operations" instead of tasks, but the counting logic is the same: each module execution is an operation, including routers, filters, and data transformers. A moderately complex Make scenario with five modules and a router runs 6+ operations per execution.

This matters because the workflows worth building aren't simple. The simple two-step automations ("when this happens, do that") are handled fine by any tool. The workflows that actually save meaningful time are the ones with conditional logic, multiple paths, data validation, and human review steps. Those are exactly the ones where per-task pricing compounds.

The automation pricing hidden cost of being careful

The pricing problem gets worse when you add human oversight, which is the right thing to do for any automation that touches client communication or anything hard to reverse.

If you're using Zapier and you want a human approval step to review a draft before it sends, you're either adding a step that routes to a third-party approval tool (billed as a task) or building the review process outside the automation entirely and reconnecting it manually. Zapier Interfaces, their native form and approval product, counts as a separate product with its own pricing. The approval loop is either expensive or awkward.

Make has similar limitations. You can build approval flows with webhooks and HTTP modules, but each module execution counts as an operation. Human oversight isn't a first-class feature, but something you construct from billing-relevant pieces.

The practical effect: per-task pricing creates a cost pressure against careful automation. The more logic you add to make your workflow smart, and the more human review steps you add to make it safe, the faster you burn through your task or operation budget. The economics reward simple, trusting automations over thoughtful, supervised ones.

What the right pricing model charges for

The case for a different pricing model comes down to distinguishing between two categories of workflow activity.

The first category is infrastructure: logic steps, conditional routing, data formatting, human review, confidence checks, error handling. This is the code that makes your automation work correctly. It doesn't call external APIs, it doesn't burn AI compute, it doesn't send emails. Charging per execution of these steps is like charging per line of code your program runs.

The second category is actions: AI calls, external API requests, integrations with third-party services, sent communications. This is where real value gets created and where real costs are incurred. An AI call to draft a reply consumes model compute. An API request to update your CRM uses that service. A sent email goes somewhere and does something in the world.

Action-based pricing charges only for the second category. Logic and human approvals are free because they're infrastructure, not actions. You can build a workflow with a hundred conditional branches, five approval steps, and three validation checks, and none of that affects your bill. You only pay when the automation does something that creates real value.

What this changes in practice

With per-task pricing, there's a tax on complexity. Every additional logic step, every added validation, every human review checkpoint makes the workflow more expensive to run. Practical experience with Zapier or Make usually ends in two places: stripped-down workflows that do less than you wanted because you were cutting billable steps, or bill surprises when a busier-than-expected month drove more executions than you planned for.

With action-based pricing, there's no reason to cut corners on logic or oversight. You can add a filter that checks for edge cases that would produce bad output. You can add a confidence check that routes uncertain executions to manual review. You can add a human approval step before every outbound email without worrying that the approval itself costs you. The workflow can be as careful as the situation demands.

This also changes how you think about adding new automations. Under per-task pricing, a new workflow that runs 500 times per month with four logic steps costs 2,000 tasks before a single external action fires. That math makes cautious, well-structured workflows feel expensive and pushes you toward simpler, blunter automations. Under action-based pricing, you design for what the workflow actually needs to do correctly, not for what you can afford to execute.

That's what comparing Rills to Zapier and Make actually comes down to in practice: not just feature lists, but what incentives the pricing model creates when you're deciding how much logic and oversight to put in your workflows.

The hidden tax in your current stack isn't just the money. It's the oversight you trimmed out because it was eating into your quota.

Human approvals are always free on Rills. You only pay for real actions: AI calls, external API requests, integrations. Logic, branching, confidence checks, and every review step cost nothing. See what your workflows could look like without the tax on being careful.