What it is
A trigger is the event that starts an automation. It's the doorbell. Nothing happens inside the house until someone presses it, and when they do, a chain of steps begins: someone walks to the door, looks through the window, decides whether to open it. In an AI workflow, the doorbell might be a new email arriving, a new row in a spreadsheet, a file dropped into a folder, a customer filling in a form, a payment going through, or a message in your team chat. When the event happens, the automation wakes up, and whatever steps you designed, including any AI steps, run on their own.
Every automation has exactly this shape: "when this happens, do that." The "when this happens" is the trigger. The "do that" is everything after it. Without a trigger, a workflow is just a recipe sitting in a drawer. With one, it becomes something that works while you sleep, and also something that can go wrong while you sleep, which is why triggers deserve their own page.
There are three things worth understanding about any trigger: what event it listens for, how it finds out the event happened, and what conditions must be true before it's allowed to start anything.
The event
The event is the specific thing that rings the bell. Good triggers are narrow and exact. "When a new order is placed in my shop" is a trigger. "When something happens with my orders" is not, because an order can be placed, paid, changed, refunded, shipped or cancelled, and each of those is a different event. Most automation tools list the events each app offers: "New email", "New labelled email", "New row", "Updated row", "New file in folder", "New form submission". Choosing the right one is half the design.
Time can also be a trigger: every Monday at 9 a.m., on the first of the month, every hour. Time-based starts have their own element, Scheduled Tasks. This page is mostly about triggers that fire because something happened, rather than because the clock said so.
How the tool finds out: polling and instant
There are two ways an automation tool can learn that your doorbell was pressed, and the difference explains a lot of puzzling behaviour.
Polling means the tool checks. Every few minutes it asks the other app, "anything new since last time?" If there is, it runs. If there isn't, it waits and asks again. This is like walking to the front door every quarter of an hour to see whether anyone is standing there. It works with almost any app, but it's slow, and a customer who filled in your form at 9:01 might not get their reply until 9:15. At the time of writing, Zapier's help centre said its polling triggers check every 15 minutes on the free plan, every 2 minutes on the Professional plan, and every minute on Team and Enterprise plans. Plans change, so check the current page.
To decide what's new, a polling tool remembers the ID of each item it has already seen (every email, row and order has a unique identifier behind the scenes) and only acts on IDs it hasn't met before. Zapier calls this deduplication. It's why editing an old row sometimes doesn't set off an automation that's watching for new rows: the ID isn't new.
Instant triggers turn this around. Instead of your tool asking, the other app tells it, the moment the event happens. The usual way to do that is a webhook: a private web address that the automation tool gives you, which you paste into the other app's settings. When the event occurs, the app sends a small package of information to that address, and the automation starts within seconds. This is a real doorbell, rather than you checking the step. Zapier marks these triggers with a lightning bolt; Make, n8n and others offer a "webhook" trigger you can connect to almost anything that can send one.
The webhook is simple and powerful, and it has one property that matters for safety: anyone who knows the address can press the bell. We'll come back to that.
Filters and conditions
A doorbell that rings for every passing car is useless. The third part of a trigger is the set of conditions that decide whether a run should really go ahead. In most tools these come straight after the trigger and are called filters, conditions, routers or paths.
- "Only if the email is from a customer address, not from our own team."
- "Only if the order total is over $50."
- "Only if the form's message field isn't empty."
- "Only if the new file ends in .pdf."
- "Only if this row's Status column says Ready."
Filters are where you turn a noisy event into a precise one. They're also where you put most of your safety rules, as the rest of this page shows. A good habit is to write the trigger and its filters as one sentence before you build anything: "When a new email arrives in the Support label, from an address outside our company, with no 'Auto-Submitted' marker, start the draft-reply workflow."
Triggers and agents
A trigger doesn't have to start a fixed workflow. It can also wake up an agent, an AI that decides its own next steps. "When a support email arrives, have an agent read it, look up the order and draft a reply" is a trigger feeding an agent. That combination is powerful and deserves extra care, because the trigger decides when the agent runs and the event decides what the agent reads first. If outsiders can create the event, outsiders are, in a small way, giving your agent its first instructions.
Why it matters
Triggers are what make automation automatic. A prompt you paste into a chatbot helps once. The same prompt behind a trigger helps every time the event happens, for months, without you remembering to do anything. For a small business, that's the difference between "I use AI sometimes" and "every new enquiry gets a tidy summary in the CRM within a minute."
The trigger sets the pace and the volume. A trigger decides how often your automation runs, which decides how much it costs. An AI step that costs a fraction of a cent is nothing on ten emails a day. Put it behind a trigger that fires on every email in a busy shared inbox, including newsletters and notifications, and you're paying for thousands of calls a month to summarise junk. Choosing the event and filters well is the cheapest cost control there is.
It's where outside input gets in. Many triggers are set off by other people: customers filling in forms, strangers sending emails, anyone who comments or replies. Whatever they type becomes the input to your automation, and if there's an AI step, it becomes part of what the AI reads. That makes the trigger a front door for prompt injection, where someone hides instructions in text in the hope that an AI will obey them (see Guardrails). Deciding who is allowed to ring the bell, and what the automation can do once it's rung, is a security decision, not only a convenience one.
Mistakes multiply at trigger speed. A person making a mistake makes it once. An automation with a bad trigger makes it every time the event happens, as fast as the events arrive. Loops, floods and duplicates are the classic trigger failures, and they are all about the automation running more often than anyone intended. The good news is that they're well understood and mostly preventable with a few simple guards.
Instant beats checking, but it has costs. Webhooks made modern automation responsive: a payment confirmed, a message posted, a reply drafted, all in seconds. The price is that you must handle whatever arrives, whenever it arrives, and you can't assume each event arrives exactly once. Payment company Stripe's developer documentation, for example, warns that a webhook endpoint "might occasionally receive the same event more than once" and advises logging event IDs so duplicates can be skipped. Any trigger can fire twice, so any step that matters should be safe to run twice.
Real-world examples
The doorbell gets a name: webhooks and IFTTT (2007 and 2010)
On 3 May 2007 a developer named Jeff Lindsay published a blog post titled "Web hooks to revolutionize the web". In it he described web hooks as user-defined callbacks made over the web: you give an application a web address, choose which events you care about, and the application sends a message to that address whenever one of those events happens. His complaint was with polling. Websites at the time mostly offered feeds and APIs that you had to check over and over, and he argued that if you could avoid polling, you would. The name stuck, lost its space, and "webhook" is now the standard word for an instant trigger across almost every app that offers automation.
The consumer version of the idea arrived soon after. IFTTT, short for "if this then that", was announced by Linden Tibbets in December 2010 and opened to the public in 2011. IFTTT's own history page says it launched with 22 services, including email, RSS feeds, date and time, weather, Twitter and Facebook. The name itself is the whole concept of a trigger in four words: "this" is the event, "that" is the action. Its simple recipes taught a great many ordinary people to think in triggers, years before language models existed. Zapier, Make and n8n all use the same shape today, with AI steps slotted in after the "if".
A $23 million book about flies (April 2011)
This is an automation story with no AI in it, and it's the clearest illustration there is of what happens when automated triggers feed each other with no ceiling.
In April 2011 a postdoctoral researcher in the lab of the biologist Michael Eisen went to buy The Making of a Fly, Peter Lawrence's out-of-print 1992 book on fly development, and found new copies on Amazon starting at $1,730,045.91, plus $3.99 shipping, from a seller called profnath, with a second seller, bordeebook, asking even more. Eisen started checking the prices each day. On his blog, in a post dated 22 April 2011, he worked out what was going on. Once a day, profnath's price was set to 0.9983 times bordeebook's, just below it. And once a day, bordeebook's price was set to about 1.27059 times profnath's, well above it. Each seller's pricing software was triggered by the other's price, and every round ratcheted both upwards. By 18 April the book was listed at $23,698,655.93, plus $3.99 shipping. The next day someone noticed, and profnath's price dropped to $106.23.
Eisen's explanation for why each rule existed was sensible on its own terms: one seller wanted always to be slightly cheapest, and the other, he suspected, didn't hold a copy and priced high enough to buy the cheaper one and still make money if anyone ordered. Each rule was reasonable. Together, they formed a loop, and nobody had set a maximum. The lessons carry straight over to AI automations: when one automation's output can become another's trigger, you can get a loop, and the fix is a ceiling (a cap on price, runs or spending) plus a person who gets told when something unusual happens.
EchoLeak: an email nobody opened becomes an instruction (June 2025)
In June 2025 the security firm Aim Security disclosed a flaw it called "EchoLeak" in Microsoft 365 Copilot, the AI assistant built into Microsoft's office apps. Microsoft tracked it as CVE-2025-32711 and rated it critical. According to SecurityWeek's report on 12 June 2025, an attacker only had to send the victim a specially crafted email containing hidden instructions. The victim didn't need to open it or click anything. Later, when the victim asked Copilot about a topic the email was written to match, Copilot pulled that email in as background material, read the hidden instructions, and could be led to gather sensitive information and send it out to the attacker. Microsoft said the problem had been fixed on its side and that customers didn't need to do anything. A research paper by Pavan Reddy and Aditya Sanjay Gujral, posted in September 2025, described EchoLeak as the first real-world "zero-click" prompt injection exploit in a production AI system.
EchoLeak wasn't an automation trigger in the Zapier sense; the victim's own question set Copilot to work. But it shows exactly what's at stake when an AI reads messages that outsiders can send. Now imagine a workflow triggered by every incoming email, which hands each message to an AI step with access to your files or your outbox. The attacker no longer has to wait for you to ask a question. Their email is the trigger, and its contents are the first thing your AI reads. That's why the Try it yourself section below treats "who can set this off?" as the first question, not the last.
GitHub Actions: a loop guard built into the rules
GitHub Actions, the automation system built into the code-hosting site GitHub, is one of the most widely used trigger systems in software. Workflows there start on events such as a push of new code, a new pull request, a new issue or label, a schedule, or a manual button. It also contains a small, deliberate loop guard. GitHub's documentation says that events caused by a workflow using the repository's built-in GITHUB_TOKEN "will not create a new workflow run", with a couple of named exceptions. In plain English: if an automation changes the code using its own built-in credentials, that change won't set off more automations, so a workflow that tidies files on every push can't trigger itself forever. Developers who genuinely want one workflow to start another have to opt in with a different credential. It's a design worth copying in your own automations: by default, things your automation does should not count as new events.
The same idea is decades older in email. RFC 3834, a 2004 standard for automatic replies such as out-of-office messages, says auto-replies should be marked with an "Auto-Submitted" header, that responders shouldn't reply to messages carrying that marker, and that a personal auto-responder shouldn't send the same reply to the same sender more than once in several days, with seven days recommended. Two out-of-office messages replying to each other forever was an early trigger loop, and those rules are the loop guard.
An everyday scenario: the newsletter import
Here's an illustrative scenario, not a real business. Priya runs a small online pottery shop. She builds an automation: when a new subscriber joins her mailing list, an AI step writes a short, personal welcome note based on the "what brings you here?" answer they gave, and the note is sent from her account. She tests it with her own address, it works beautifully, and she switches it on.
A month later she moves her mailing list to a new provider and imports her existing 5,000 subscribers. To the new provider, each imported person is a "new subscriber". Her webhook trigger fires 5,000 times in a few minutes. Each run calls the AI, and each run sends an email. Long-standing customers receive a gushing "welcome to the shop!" note, some of them from people who have been buying from her for years, and her AI bill for the day is larger than the whole previous month.
Nothing was broken. The trigger did exactly what it was told. What was missing were three guards: a filter ("only if the subscriber's join date is today and they weren't imported"), a daily cap ("stop after 50 runs and email me"), and a draft step instead of an automatic send. Zapier's help centre describes a built-in protection for this situation, which it calls flood protection: if 100 or more events arrive at once on a polling trigger, it holds them and emails you to confirm. But the same page notes that most instant (webhook) triggers are exempt, which is exactly the kind of trigger Priya used. Built-in protections are welcome; your own caps are the ones you can count on.
Try it yourself
This takes about 30 minutes and needs nothing but a notepad and a free chatbot account. You won't build anything live; you'll design a trigger on paper and have an AI try to break it, which is where most of the value is.
- List three events in your work that could be triggers. Think of things that happen repeatedly and currently make you do something by hand. Examples: "A customer fills in the contact form", "A new review appears", "A new invoice PDF lands in my Downloads folder", "Someone buys the ebook", "A new episode is published". Write each one as "When … happens".
- Pick the one with the least risk. Prefer one where the automation only produces a note, a spreadsheet row or a draft, and where the event comes from you or from a trusted system rather than from strangers. Save anything that sends, pays, publishes or deletes for later.
- Pin down the exact event and how it's detected. Which app, which event from its list, and is it polling or instant (webhook)? If polling, how long a delay is acceptable?
- Write your filters. At least two conditions that must be true for a run to start. One should exclude events your own automation creates. For example: "Only if the sender is not my own address and the subject doesn't start with [Auto]."
- Add a loop guard. Decide how the automation marks its own output so it will never react to it. A label, a column value ("Processed = yes"), a tag in the subject line, or writing to a different place from the one it watches. Watching one folder and saving results into a different folder is the simplest loop guard there is.
- Add a duplicate guard. Decide what unique ID you'll record for each event (order number, email ID, row number) and add the rule "skip if this ID is already in the log".
- Add a daily cap. Choose a number well above your normal volume but far below a disaster, for example "no more than 50 runs a day", and decide what happens when it's reached: stop, and send me an email. Also set a monthly spending limit in your AI account's billing settings, if it offers one, so a mistake has a ceiling in money as well as runs.
- Decide who can ring the bell. If outsiders can create the event (a public form, an inbox anyone can email, a comment box), write down what the AI step is allowed to do with their text. The safe default is: it can summarise and label, but it cannot send, forward, look up private files or take any action based on instructions inside the message.
- Plan a safe test. Write down how you'll test with a copy: a test spreadsheet instead of the real one, your own address instead of a customer's, a test folder, a test product. List three awkward test events, such as an empty form, a very long message, and an event your own automation just created.
- Stress-test it with a chatbot. Paste your design into a chatbot with the prompt below, and read what it finds. Change your design and ask again until the answers stop surprising you.
I'm designing an automation trigger for my small business. I'm not a
programmer. Please act as a careful reviewer and try to break my design.
My design:
- Event (what starts it): [describe]
- Polling or instant (webhook): [say which, or "not sure"]
- Filters (must all be true to run): [list]
- What the automation does next, including any AI step: [describe]
- Loop guard (how it avoids reacting to its own output): [describe]
- Duplicate guard: [describe]
- Daily cap and what happens when it's reached: [describe]
- Who can create the triggering event: [me only / my team / customers / anyone]
Please check for:
1. Ways it could trigger itself or be triggered by another automation (loops).
2. Situations where it could fire hundreds or thousands of times at once
(bulk imports, migrations, backlogs, reconnecting an account).
3. Ways the same event could be processed twice, and what harm that would do.
4. Ways an outsider could misuse it, including hiding instructions in a
form or email for the AI step to follow (prompt injection).
5. What it would cost in the worst realistic day, and whether my cap is right.
6. What I should test with a safe copy before switching it on, as a list
of specific test events.
Be concrete. For each problem, suggest the simplest fix a non-programmer
could make in a no-code tool. Don't assume features my tool may not have;
tell me what to look for instead.
If you then decide to build it in a tool such as Zapier, Make or n8n, keep the first version ending in a draft or a spreadsheet row, run it against your test copy, and only point it at the real thing once the test events all behave. Free plans and trigger options change often, so check each tool's current terms before you start.
Common mistakes and misunderstandings
Watching the same place you write to. The most common loop: an automation watches a spreadsheet for updated rows, and its own step updates a row, which counts as an update, which triggers it again. The same happens with an inbox rule that replies to emails and then sees its own reply, or a folder watcher that saves its output into the folder it's watching. Zapier's help centre has a page on exactly this, and its first advice is to switch the looping automation off at once. Write your output somewhere else, or mark it so your filters skip it.
Assuming each event arrives exactly once. Instant triggers can deliver the same event twice, for example when the sending app didn't get a quick "received" reply and tried again. Polling triggers can re-run old items after an app reconnects or an ID changes. If a double run would send a customer two emails, or charge twice, you need a duplicate guard that records IDs and skips repeats.
Forgetting about bulk events. Imports, migrations, restoring a backup, reconnecting an account after a password change, or clearing a backlog can all look like thousands of brand-new events. Before any big change to a connected app, switch your automations off, make the change, and switch them back on with a cap in place.
Relying only on the tool's safety net. Some platforms hold unusually large batches for you to confirm, but these protections have limits and exceptions, and they don't know what normal looks like for your business. A daily cap you set yourself, plus a spending limit with your AI provider, is what actually protects you.
Treating outside input as trusted. A public form, a support inbox or a comment box lets anyone on the internet start your automation and choose the text your AI reads first. Assume some of it will be spam, some will be abusive, and occasionally some will contain instructions aimed at your AI. Keep AI steps triggered by outsiders to low-risk jobs such as summarising and sorting, and put a human in the loop between that AI and anything that sends, pays or reveals information. See Guardrails for more on checks.
Leaving webhook addresses lying around. A webhook address is like a key to your doorbell: anyone who has it can set off your automation. Don't paste it into public pages or shared documents, use the tool's authentication or secret-token options where they exist, and create a new address if an old one might have leaked. If you run your own automation server, keep it updated; the n8n "Ni8mare" flaw described on the Workflow Automation page came in through webhook-style triggers.
Testing on the real thing. Testing a trigger means making the event happen, and if the event is real, so are the consequences. Use a copy: a test sheet, a test folder, your own email address, a test product, a sandbox mode if the app offers one. Only switch the trigger to the real source after your test events behave.
Too broad a trigger, fixed later with AI. It's tempting to trigger on every email and let the AI decide which ones matter. That makes you pay for an AI call on every newsletter and receipt, and gives the AI the job a simple filter could do for free. Narrow the trigger first with ordinary filters (sender, label, subject, field values), and only use AI on what's left.
Confusing triggers with schedules. "Every morning at 8, summarise yesterday's emails" and "when an email arrives, summarise it" sound similar but behave very differently: one runs once a day on a batch, the other runs per event, possibly hundreds of times. Batches on a schedule are often cheaper and easier to review. See Scheduled Tasks.
Not watching after launch. A trigger that worked in testing can change behaviour when an app updates or your volume grows. Check the run history weekly at first, turn on failure alerts, and keep an eye on run counts and costs. That habit is what Observability is about.
Related elements
- Workflow Automation: the chains of steps that triggers start, and the tools used to build them.
- Scheduled Tasks: automations started by the clock rather than by an event.
- Agent: the kind of AI a trigger can wake up to decide its own next steps.
- Orchestration: coordinating many triggered steps, tools and agents together.
- Handoffs: passing work between agents or people once a triggered run is underway.
- API: the connection apps use to report events and receive instructions.
- Guardrails: the checks that stop outside input or bad output from causing harm.
- Human in the Loop: the approval step between a triggered AI draft and anything that goes out.
- Observability: watching run counts, errors and costs after a trigger goes live.
- Autonomy Levels: how much a triggered system should be allowed to do without asking.