What Automating One Process Actually Costs

Someone on your team asks the reasonable question: how much would it cost to automate this? The task is a lead-to-CRM handoff, or the month-end invoice run, or pulling numbers out of PDFs. You look up a tool, see $20 a month, and the meeting moves on. Three months later the workflow works most days, one person quietly babysits it, and a vendor API change has broken it twice. The $20 was real. It just answered the smallest of the questions you were actually asking.

Automating one process has three costs, not one, and they live on different clocks. There is what it costs to build, what it costs to run, and what it costs to keep running. The tool subscription everyone quotes is the run cost, and for most workflows it is the smallest of the three. Below, all three are priced for a single process, with current vendor numbers, so you can put a real figure in the budget instead of a sticker. If your question is who should build it, whether your team, a product, a hire, or a studio, that is a different decision, and the four routes are costed in build vs buy vs hire.

The three costs hiding in "how much to automate this"

Pin the three down, because they get collapsed into one number, and that is where budgets go wrong.

Build cost is one-time. Mapping the process, wiring the trigger to the systems it touches, handling the records that do not fit the happy path, and testing it against real data. You pay it once, up front, mostly in hours.
Run cost is recurring and scales with volume. The platform charges per task, per operation, or per execution, and if an AI step is involved, the model charges per call. This is the meter. It is also the number printed on the pricing page, which is why it is the one people quote.
Maintenance cost is recurring and hidden. An API changes, a CSV grows a column, a silent failure needs catching. Someone owns the thing and spends hours on it that never show up as a line item. Over two or three years, this is often the largest of the three.

The mistake is pricing the middle one and ignoring the outer two. A $9 Make plan is a true number and a useless budget.

Run cost: the meter that scales with volume

Start here, because it is the part with published prices. The three main no-code platforms each meter differently, and the unit matters more than the headline price.

| Platform | Entry paid plan | Price | Included volume | Billing unit | |---|---|---|---|---| | Zapier | Professional | $19.99/mo (billed annually) | 750 tasks/mo | A task is each successful step in a Zap | | Make | Core | $9/mo (billed annually) | 10,000 credits/mo | One credit per module action | | n8n Cloud | Starter | $20/mo (billed annually) | 2,500 executions/mo | One execution is a full workflow run |

Sources: Zapier's pricing page, Make's pricing page, and n8n's pricing page.

The billing unit is where the real cost hides. A five-step Zap burns five tasks every time it fires, and many actions cost more than one, so 750 tasks can mean well under 150 runs. Make counts each module action as a credit. n8n counts the whole workflow as one execution no matter how many steps it has, which is why the same busy workflow can be far cheaper there. The task-versus-execution gap gets broken down in n8n vs Zapier. Pick the wrong meter for your shape of work and a workflow that fires thousands of times a month quietly outgrows the plan you budgeted.

The AI line, if the process needs one

If the process includes a judgment step, whether reading a PDF, classifying a ticket, or drafting a reply, a language model runs per call, and that is a separate meter on top of the platform. The rate is low per item. Claude Haiku 4.5 is $1 per million input tokens and $5 per million output tokens. In Anthropic's own worked example, processing about 10,000 support tickets at roughly 3,700 tokens each runs about $37. The AI is rarely the expensive part. What it adds to the budget is not the tokens, it is the confidence gate and the human review the workflow now needs, and that lands in build and maintenance, not run.

Build cost: the one-time line that dwarfs the subscription in year one

The build is the biggest number in the first year, and it is the one with no price tag on a website. Building a process automation is not turning on a tool. It is:

Mapping the trigger and every system the process touches, in order.
Wiring the integrations, including the ones the tool does not cover natively.
Handling the records that break the happy path: the company name with a comma, the duplicate contact, the deal that closed in the wrong currency.
Adding error handling so a failure surfaces instead of vanishing.
Testing against real data, not the one clean example.

That is hours, and hours have a rate. Whether your team spends them or you pay someone, the build is where most of the first-year cost sits, and the edge cases are most of the build. The happy-path version, where a form fills and a record lands in the CRM, takes an afternoon. The version that survives the comma, the duplicate, and the API timeout takes the rest of the week. Skip that work and you have not saved the build cost. You have moved it into maintenance, where it is more expensive.

Maintenance: the line nobody puts in the budget

An automation is not a purchase, it is a dependency. It sits on top of other companies' APIs, and those move without asking you. HubSpot deprecates an endpoint. Stripe changes a webhook payload. A vendor CSV grows a column and the parser silently starts writing blanks. None of that announces itself. The workflow keeps reporting success while doing the wrong thing, and you find out when a customer does.

Maintenance is the hours to catch that and fix it, plus the monitoring that tells a human before the customer does. It is small in any given month and relentless across a year, and it lands on whoever built the thing, usually one person, usually undocumented, and usually the reason "quick automation" becomes a second job. Over a two-to-three-year life, the upkeep on a workflow that matters routinely costs more than the build did. It is also the line left out of every DIY estimate, which is why DIY so often comes in over budget without anyone being able to say where.

Worked example: one process, costed across its first year

Take the workflow most teams recognize. A form submission creates a CRM contact, tags it, and posts to Slack. When the deal closes, the system generates the Stripe invoice and drops the link in a finance sheet. Call it a few hundred runs a month across six steps, with no AI step. Here is where the money actually goes.

| Cost line | What it is | Rough size, year one | |---|---|---| | Run | Platform subscription at this volume | ~$10 to $30/mo, so ~$120 to $360/yr | | Build | Mapping, integrations, edge cases, testing | The bulk of year one, paid in hours or a fixed fee | | Maintenance | Fixes when an API changes, plus monitoring | Small monthly, ongoing, cumulative |

The run cost is the confident number and the least important one. The subscription is real and small. What decides the total is the build and the upkeep, and those are hours, not a price on a page. This is the trap in "it's only $20 a month": the $20 is true, and it is a rounding error next to the week of building and the year of babysitting that make the workflow actually run. We walked one real build end to end in our automation case study.

Where working with bottta changes the math

For a lean team, the honest recommendation is to stop pricing this as a subscription plus your own unpriced hours, and price it as a build. That is what a studio like bottta sells, and it is why we lead with it. We design and build the process, handle the edge cases, wire the integrations, and add the monitoring, then hand you a workflow that runs instead of a canvas you have to learn.

There are two ways to work with us, and they map onto the cost structure directly:

The $4K project turns the build line into a fixed, known number. Fixed scope, fixed price, integrations included, the edge cases handled, and 30 days of post-launch support. This is the right call for one process that needs to exist and run reliably. Instead of an open-ended hours estimate that lands on your team, you get one figure.
The $3K/month retainer covers the maintenance line for up to three active workflows at a time: ongoing monitoring, fixes when an API shifts, and the upkeep that otherwise becomes someone's second job. This is for teams with a few processes that have to keep running.

The design is the durable part, not the wiring. Clear triggers, sane handling for the record that does not fit, and monitoring that pages a human instead of failing silently at 2am. That is the difference between a workflow that pays for itself for years and one that quietly costs more than the manual process it replaced.

How to budget for automating one process

Price all three lines before you commit, and let volume and stakes decide the shape.

Low volume, stable inputs, low stakes. A simple Make or n8n build your team owns without a developer. The run cost is a rounding error, the build is an afternoon, and the maintenance is rare. This is the one case where the cheap sticker is close to the true cost. Confirm it is worth automating at all with our test for what to automate.
Real volume or an AI step in the loop. Budget the run cost seriously and match the platform's billing unit to your shape of work. Check the meter against the workflow tool comparison, because the wrong unit is where run costs surprise you.
The process matters and has to keep running. Budget the build as a fixed fee and the maintenance as an ongoing line. This is the fixed-price project or the retainer, and it is where a studio is cheaper in total than keeping it in-house once you count the hours DIY hides.

The most expensive automation is the one budgeted as a subscription and paid for in unbudgeted hours for two years.

Frequently asked questions

How much does it cost to automate one process? The run cost is small and public: a no-code plan is $9 to $30 a month at low volume. The build and the maintenance are the real total, and they are hours rather than a subscription. For a process that has to run reliably, a fixed-price build like bottta's $4K project turns the open-ended part into one known number.

Why is the tool subscription so much cheaper than the total cost? Because the subscription only meters the running, not the building or the upkeep. A $9 Make plan is a true number for the credits it includes, but it does not cover mapping the process, handling edge cases, or fixing the workflow when an API changes. Those are the larger costs, and they never appear on a pricing page.

Does adding AI make automating a process much more expensive? The token cost usually does not. Claude Haiku 4.5 runs $1 per million input tokens and $5 per million output, and Anthropic's own example processes about 10,000 items for roughly $37. What AI adds to the budget is the confidence gate and human review around it, which is build and maintenance work, not the per-call rate.

What is the cheapest way to automate a single workflow? If it is simple, stable, and low-stakes, build it yourself on Make or n8n and keep it small. If it matters and has to keep running, the cheapest path over its life is usually a fixed-price build, because DIY's real cost is the hours it hides, not the subscription it shows.

Price a process across all three lines and the cheap answer and the honest answer stop being the same number. The subscription is the easy part. The build and the upkeep are the decision. If you want that figure as one fixed number instead of an open-ended hours estimate, start a project with bottta or book a call.