Working with AI

Automation with AI

Automation means an event happens, a few steps run after it, and an action is taken at the end, without anyone pressing a button. AI belongs only at the step that needs judgment; every step that a simple condition solves should stay a condition, because a condition costs nothing, invents nothing, and makes a noise when it breaks.

  • Lesson 10 of 15
  • Intermediate
  • Free, no signup

Trigger, steps, action

These five links sit under every automation, from a two step Zap to a thirty step workflow. The only link that needs a model is the third.

  1. 1 Trigger

    A form was submitted, an email arrived, the clock hit. This is where Zapier has a polling interval and the cheaper plan sees it later.

  2. 2 Condition

    A plain filter, no model. It costs nothing, invents nothing, and always gives one answer.

  3. 3 Judgment

    The only step that needs a model: classify, summarise, translate. Ask for structured output, not free text.

  4. 4 Human gate

    Wherever output leaves the organisation or changes something. Always manual for the first week.

  5. 5 Action

    A message, a row, a ticket. Put a cap here too, so one error does not become repeated sends.

No point in this chain announces on its own that it has snapped. Monitoring is not an extra link, it is part of building the thing.

Last checked: Facts and tool names in this lesson are re-checked against their sources on this date.

What an automation is made of, and where the AI sits

Every automation, from the simplest to the most elaborate, has three parts. A trigger that starts it: a form was submitted, an email arrived, the clock hit seven. A few steps that transform the data: filter, convert, call another service. And an action at the end: a message was sent, a row was written, a ticket was created. That is all. Open any automation tool and if you see more than that, you are looking at a more elaborate version of those same three things.

Now the real question: where does AI come in. The short answer is only at the steps that need judgment. Whether an email came from a particular address is not judgment, it is a condition. Whether the text of that email is a complaint or a price question is judgment. Mix the two and you end up with a system that pays for work an if statement already solved, and that sometimes answers differently.

Our position is blunt: most of what is sold today as AI automation is ordinary automation with a model glued on top. That is not a bad thing, but when the name changes the price changes with it. The question to ask is which step of this workflow cannot happen without a model. If the answer is none of them, you want automation rather than AI, and that is cheaper and steadier.

A chain of glass links: a red bell, green gears, one blue brain and a white stamp

The question to ask at every step

Can this step happen without a model

yes

Make it a condition

  • sender, date, amount, whether a field exists
  • always one answer, at no cost
  • when it breaks it throws an error
no

Put the model here

  • the subject of a message, tone, summary, translation
  • ask for structured output, not free text
  • one identical question gets two answers

This question is about possibility, not quality. A model can do the left hand jobs too, it just does them more expensively and less reliably.

n8n, Zapier and Make: the difference that hits the bill

The most important difference between these three is not the interface, it is the unit they count. The n8n pricing page states that pricing is based on monthly workflow executions, regardless of complexity. So a thirty step workflow still counts as one execution. Zapier bills per task, and its own page says AI steps, code and the SDK now all follow that same task based model. The difference shows up as soon as your workflow gains a few steps, and most comparisons that only set the base prices side by side never reach it.

We read the figures off their own pages the same day. On n8n, the Starter plan is 20 euros a month billed annually and gives 2,500 executions, Pro is 50 euros and 10,000 executions, and Business is 667 euros and 40,000 executions. On Zapier, the Free plan is 0 dollars with 100 tasks a month, two step Zaps only and a 15 minute polling interval; Professional starts at 19.99 dollars with multi step Zaps and 2 minute polling; and Team starts at 69 dollars with 25 users and 1 minute polling.

We print no figure for Make, and we say plainly why: the make.com domain returns a 403 to this server, on the front page and on the pricing page alike, even with an ordinary browser user agent. We do not write a price we have not read off the vendor page ourselves, and that single fact says something about access too: a service whose public page will not open for you is a problem that started before you ever created an account.

And one point that matters to an Iranian reader more than all three sets of numbers above: n8n can be run on your own server, and its documentation gives the Docker install route. That removes the question of reaching an outside service and replaces it with a different one, which the n8n documentation states outright: self hosting takes technical knowledge, mistakes there lead to data loss, security issues and downtime, and for that reason it recommends self hosting to expert users.

Read the n8n license before you sell it to a client

Few people read this clause, and for an agency it is exactly where the trouble starts. The LICENSE.md file on the main branch of the n8n repository says most of the software is released under the Sustainable Use License version 1.0, and that license states plainly that you may use or modify the software only for your own internal business purposes or for non commercial or personal use, and that you may distribute it or provide it to others only free of charge and for non commercial purposes.

The practical translation for a web agency is this: standing up n8n on your own server and automating your own internal work is that internal use, and it is fine. Standing up an n8n instance and selling it to your clients as a service is the thing this clause is about. The same file carries a second point engineers usually miss: files with .ee. in the filename or .ee in the directory name are not under that license at all and require a separate enterprise license.

We do not write this to frighten anyone and we pass no judgment on anyone legal position; we write it because it is the same pattern you saw in the open models lesson, repeating here: free and unrestricted are not the same word, and the boundary between them is always written in the LICENSE file rather than on the marketing page. Fifteen minutes reading that file before a proposal goes to a client is the cheapest thing you can do in this field.

Three real automations, step by step

One, the contact form lead. The trigger is a contact form submission. The first step is a plain condition, not a model: if the phone field is empty or the message is under ten characters, it is spam and it ends there. The second step is the model, and the only step that needs one: read the message text and say what it is about and what budget range was mentioned, as structured output with fixed fields. The third step is a condition again: route it to the right person based on that subject. The fourth step is the action: a message to the team channel carrying the original text, not only the model summary. And the fifth step, always forgotten: no reply is sent to the customer. A person sends it.

Two, the weekly Search Console report. The trigger is a schedule, say Saturday morning. The first step pulls this week and last week. The second step is arithmetic, not a model: isolate the queries whose average position got worse than last week and that carry meaningful impressions. A model has no business here and if you let it in, it will give you a wrong number. The third step is the model: hand it that numeric list and have it write one line per row saying which page of the site the query belongs to and what may have changed, stating that this is a guess. The fourth step is the action: an email with the table of numbers at the top and the model guesses below it, in that order and not the reverse, because a tired reader only reads the top of an email.

Three, the translation draft for a new post. The trigger is a post being published. The first step gathers the text and the list of terms that have a fixed translation, which is your glossary. The second step is the model, and it must see the glossary inside the same prompt, otherwise it invents a fresh equivalent every time. The third step is a condition: if the output is shorter than seventy percent of the source, something was dropped and it gets flagged. The fourth step is the action: the draft is saved as a draft, not published. That fourth step is not negotiable and the next section says why.

In all three the pattern is identical, and deliberately so: conditions carry the work forward, the model appears only where judgment is required, and the last step that touches the outside world belongs to a person. Build a workflow without those three properties and you will have built it faster and found out later that it does not work.

An automation that breaks makes no noise

There are two shapes of failure and both are silent. The first is the automation stopping with nobody noticing, because producing no output looks exactly like a day with no input. The second and worse is stopping but not completely: the last step runs twice, or the same message goes out every five minutes. The first takes weeks to be spotted and the second takes hours, but by the time the second is spotted it has already embarrassed you in front of a client.

Three things prevent most of this and none of them is hard. A heartbeat: have the automation write a row with a timestamp on every successful run, and have a separate check alert you when the latest row gets older than some limit. That is, instead of waiting for an error you wait for silence. A cap: if the number of runs in an hour passes a set figure, stop. And a kill switch that is reachable and that everyone knows the location of.

And one habit cheaper than all three: keep the last step, the one that reaches the outside world, manual for the first week. Let the automation do its work and put the result in a queue, and you look and send. If after a week there was nothing in that queue you needed to stop, then automate it. That is the only way to learn without risk that the system really works rather than merely resembling work.

Four things that must be there and four that must not

The monitoring sheet, before you leave an automation alonefirst week

Must exist before you walk away

  • a heartbeat: every successful run writes a timestamped row
  • a silence alert: warn when the latest row gets stale
  • a cap on runs per hour, against repeated sends
  • a kill switch everyone knows the location of

Do not lean on these four

  • the platform own error email, which only catches its own errors
  • the belief that you would obviously notice a breakage
  • a weekly report, which shows a three day outage too late
  • automatic sending in the first week

This sheet catches silent failures, not content mistakes. A model that classified something wrongly walks straight past it, and only manual sampling finds that.

The fast path, with AI

The fast path is not having a model build the workflow for you; the tools change every few months and output written for last year version costs you time. The fast path is having it write the spec: the table that says, for each step, rule or judgment, how it breaks and who finds out. Building a workflow from a table like that is half a day; building one without it is two weeks and a silent automation. Use a strong model, because this is judgment work.

  1. Write, in a few lines, the job you do by hand today, the way it actually happens. Include the exceptions, because the exceptions are where an automation breaks.
  2. Run the recipe below and take the table. Do not drop the silence column; it is the column other checklists do not have.
  3. Look again yourself at every row the model marked as judgment. Models tend to count simple work as judgment too, and every extra judgment means extra cost and extra instability.
  4. Build only the rule column first and work with that for a week. Add the judgment steps the following week, one at a time, sampling the week output each time.

Copy-ready recipe

The job written below is done by hand today and I want to automate it. Do not name tools and do not recommend products.

The job: {the few lines you wrote}
What must never happen: {for example, no message reaches a customer without my approval}
Volume: {for example, about 20 items a day}

Give me a table, one row per step, with these columns:
step | fixed rule or judgment | input required | if this step breaks, what does the breakage look like | is the breakage loud or silent | who finds out

Rules:
- Mark any step a simple comparison or condition can solve as a rule, even if a model could also do it.
- For each judgment step, write which fields its output must contain.
- Take the silence column seriously: explicitly mark as silent any step whose failure produces no error.

After the table, say in five lines what I would lose if I built only the rule rows and used no model at all.

Before you trust the output: The table is a map, not a working system. Review three things yourself: the rule or judgment column, because a model tends to make its own role larger than it is; the silence column, because silent failures are the ones a model sees least too; and the last step that reaches outside, which does not get automated until you have watched a week of its output with your own eyes. And if the last five lines conclude that nothing important is lost without a model, those five lines are the most valuable thing this recipe gave you.

AI in this kind of work

Inside an automation the model plays the part of one step rather than the part of the system, which makes choosing a tool here different from choosing one for conversation. What matters is that it returns structured output and keeps the same shape across a thousand runs, not that it shines in one long answer. Our position: for mechanical high volume steps such as classification and tagging, take a fast cheap model and spend the money you saved on manually sampling the output. That sampling is the thing no model replaces.

Tools that actually help

  • n8n The most important option for an Iranian reader, because it runs on your own server. Its cloud pricing counts workflow executions rather than steps. Read its license before selling it to a client; the section above says why.
  • Zapier The quickest to set up and good for testing an idea in an afternoon. It bills per task, so a long workflow on Zapier costs more than you would guess from the plan price.
  • Gemini It handles Persian well and is a reasonable pick for the classification and tagging step on Persian messages. Google own page says the Gemini web app runs in over 230 countries and territories, and Iran is not on that list.
  • Claude For writing the automation spec itself, the table in the section above, it answers more directly and is readier to say that a step needs no model at all. Iran is on neither of the two Anthropic supported-countries lists.

Where it backfires

The specific risk of automation is that both of its failure modes are silent. An automation that has stopped announces nothing, because the absence of output is indistinguishable from the absence of input; and an automation stuck in a loop announces nothing either, it just sends the same message repeatedly, and the person receiving it tells you, not your system. That is why monitoring is part of building rather than a job for later. The second risk is about data: any step that sends the text of a customer message to an outside service has moved that text out of your organisation, and whether it is used for training depends on plan and settings, which Anthropic sets out on its privacy page; in an automation this risk is larger than in a manual conversation, because it repeats a thousand times a day and nobody thinks about it each time. The third risk is the compounding error from the agents lesson in its cheaper form: one wrong classification at step two becomes one wrong message to a real customer at step four, unless a person stands between them. For how access and payment for these tools stands from Iran, see the buying guide.

Sources: n8n: plans and pricing Zapier: plans and pricing n8n: Sustainable Use License n8n: self hosting takes technical knowledge Anthropic: is my data used for model training

Where this advice stops

The prices on this page are the state on 6 September 2026 and the plans of these services change every few months; the checked date at the top of the page exists for exactly that. We print no figure for Make because its page will not open for this server, so this lesson is a two way comparison rather than a three way one. We have not run n8n on our own infrastructure and make no claim about its resource use or stability; what is written about self hosting comes from the n8n documentation. And finally, the license section is an explanation of a text and not a legal opinion.

From our own work

This server holds a trap that silently kills any webhook driven automation, and it cost us time to find. The php.ini file says max_execution_time = 900 on line 404, but php-fpm.conf says request_terminate_timeout = 180 on line 40, and the one that wins is the second. So any request past three minutes is killed with a signal, and when a process dies by signal, shutdown functions and finally blocks do not run at all. The result is exactly what this lesson warns about: the on error branch of your code never runs, so the automation does not report an error, it reports nothing. That 900 in php.ini is a decoy and we fell for it first. Since then, the long running cron jobs on this site are written to work under that budget on each pass and resume where they stopped.

Real follow-up questions

To start out, is n8n better or Zapier

If you want to test an idea in an afternoon, Zapier is faster. If the workflow has many steps, or the data must not leave your server, n8n makes more sense, because it counts executions and it also runs on your own server. Read the n8n license before you sell it to a client.

Which model should I use inside an automation

For mechanical high volume steps such as classification and tagging, a fast cheap model is enough. Keep the expensive model for the place that genuinely needs judgment. Take today pick from the AI reference section of this site rather than from a model name written in some tutorial.

How do I know my automation has broken

By waiting for silence rather than for an error. Have every successful run write a timestamped row and have a separate check warn you when the latest row gets older than a set limit. The platform own error email is not enough, because it only sees its own errors and not a complete stop.

Keep learning