Stop Making People Do Repetitive Work: In-Product Automation Rules for Vibe Projects
In-product automation rules hand repetitive work to the product itself: a user configures one 'if this, then that' and matching work happens automatically. This guide covers the do-the-math test, templates, triggers, conditions, safe actions, and rule management. All example products and figures are fictional.

The most wasteful work in a small team is rarely the hard work — it is the repeated work. A card dragged to "Done" needs a manual @ to the tester; every Friday afternoon, the week's finished tasks get copied one by one into a weekly report; a new user signs up and someone manually sends a welcome email and manually creates a trial task. Each job takes two minutes, but ten times a day adds up to a dozen hours a month. In-product automation rules hand those repeated jobs to the product itself: a user configures one "if this, then that", and from then on the product does matching work automatically.
This guide covers automation rules that users configure themselves inside the product: how to pick triggers, how to write conditions, how to make actions safe, and how to manage rules once there are many of them. Every example below is fictional: the product is "Baiyang Board", a kanban collaboration app for small teams, and "Lao Chen" is its independent developer. All trigger counts and hours saved are invented examples to explain the method, not real operating data from any product. Boundaries first: background jobs that run on a server schedule belong to our guide on scheduled tasks; automated replies and triage in support belong to our guide on support automation; pushing product events out to external systems belongs to our guide on webhook integration. This guide is only about rules a user can set up in a few clicks inside the product — no code, no server scheduling.

1. Do the math first: three numbers that decide whether to automate
Before writing the first rule, do the math: how many times a month does this happen, how many minutes does it take by hand each time, and how often does the manual version go wrong? Multiply the three numbers and you get the hours one rule saves each month. Baiyang Board's first rule came from exactly this: after a card was dragged to "Done", someone manually @-mentioned a tester for review — 120 times a month, two minutes each to find the person, type, and confirm, which is four hours a month. One rule that @-mentions automatically saves those four hours.
Three kinds of work, on the other hand, are not worth automating. The first happens once or twice a month: configuring the rule takes longer than doing the job by hand for a year. The second has a judgment standard nobody can state: "if this document is well written, send it to everyone" — "well written" lives in a human head, can't be written as a condition, and a rule forced out of it will only send the wrong things. The third is work where one mistake costs dearly: "ship the goods automatically when a customer pays" — one wrong shipment means refunds and apologies, so manual confirmation beats saving effort.
A practical test: do the job by hand for two weeks, noting each time how long it took and how often it went wrong. After two weeks, look back: whichever action recurs most and fails most often gets automated first. Don't start by listing twenty rules — build one, run it for two weeks, confirm it saved time, then build the next. Automation compounds: once the first rule runs smoothly, the team trusts the second one.
2. Don't start from a blank editor: give three template rules first
The worst thing a rule editor can show is a blank page: three dropdowns for trigger, condition, and action, and a user with no idea where to begin. Baiyang Board's approach: creating a rule starts with three templates, not an editor. The first is "notify the tester when a card is done": when a card is dragged to the "Done" column, @-mention the person responsible for testing. The second is "daily reminder for overdue tasks": every morning at 9 a.m., list today's due tasks and send them to their owners. The third is "welcome a new member": when someone joins a board, post a welcome message on the board and create a "read this first" task.
Templates help in three ways. First, users can edit and use them: swap "the tester" for a real person, change "9 a.m. daily" to "9 a.m. Mondays", and the rule is live. Second, templates teach: after using three of them, users understand what triggers, conditions, and actions do, and need no more teaching next time. Third, templates guard the quality floor: every action in a template is a verified safe action, so nobody's first rule is "delete all overdue tasks".
Templates should also be handed out by seniority. Newly registered teams get the three simplest; teams a month in get two advanced ones on the rules list page, such as "a high-priority card overdue by two days escalates to its owner". Six to eight templates are enough — more and users can't choose, which is the same as having none. Keep only the best template per category and delete the weaker one.
When a template changes, rules already built from it are unaffected — the moment a rule is created from a template, the template's trigger, condition, and action are copied into the rule itself, and later template edits never touch rules already running. Say this plainly on the template page, or users will worry that "editing the template might break my running rules". A template is a starting point, not a remote control.
3. Picking triggers: a status changed, a time arrived, a field changed
A rule has three parts: trigger, condition, action. The trigger — "when does it run" — has only three reliable kinds: a status changed, a time arrived, a field changed. A status change is a card dragged from one column to another, or a task moving from "In progress" to "Done". A time arrival is 9 a.m. every day, every Monday, or one day before a deadline. A field change is the owner switching from one person to another, or priority changing from "Medium" to "High".
Trigger selection has two rules. First, one rule gets exactly one trigger. With several triggers, nobody can say when the rule runs: does it run "when the status changes" or "when the time arrives"? Two triggers each firing once means the action runs twice, and the tester gets the same @ twice a day. Second, don't use polling as a trigger: never write "check every minute for overdue tasks" — write "check at 9 a.m. every day". The first runs 1,440 times a day, exhausts the server, floods the logs, and can send the same reminder a dozen times; the second runs once a day, which is enough.
Another common trap: the trigger must fire at the moment the change happens. Fire the instant a card lands in "Done" — not when the user next refreshes the page. Fire at 9 a.m. the day before a deadline — not on the deadline day itself. A late trigger makes the action pointless: the tester learning on Friday that "this card was finished on Monday" might as well not have been told.
4. Writing conditions: "AND" first, "OR" only when needed
Conditions are the part of a rule most often written wrong. Baiyang Board's condition editor offers only two connectors: AND and OR, and the default is AND. For example, "when a card is dragged to Done AND the owner is the test group, @ the test lead" — both conditions must hold before it runs, which is hard to get wrong. When is OR the right choice? For example, "if priority is High OR a customer is waiting, mark it red" — either condition alone is enough. AND is the default, OR is the exception; don't reverse that order.
Conflicting conditions appear as soon as rules multiply. Two rules hit the same card at once: one says "@ the tester when done", the other says "archive when done" — which runs first? Baiyang Board's answer has three parts: first, the rules list has an explicit top-to-bottom order, running in order and stopping after one rule unless the user ticked "continue to the next rule"; second, rules whose actions contradict each other can't both be on, and the system warns "both rules would move the same card — turn one off first"; third, each rule's run log records which rule ran, when, and which card it touched, so problems can be traced.
Conditions must also stay readable six months later. Write "priority equals High", not "field A equals 3". Split a rule when its conditions exceed three, and split again when one condition mixes AND and OR. Rules are for the team, not for showing off to the person who wrote them.
5. Designing actions: re-runnable, rate-limited, and loud when they fail
Actions are where rules do the real work — and where they cause the most trouble. Action design has three iron rules. The first is idempotence: running the same rule on the same card twice must produce the same result as running it once. Sending a notification twice is harmless, but "subtract ¥100 from the budget" run twice subtracts ¥200. The fix: before executing, record "this card, this rule, already ran today" and skip repeats. The second is rate limiting: one rule may run at most 50 times an hour; beyond that it stops, logs the event, and tells an admin. Without a limit, one false trigger can send 500 @-mentions in a minute and make every phone on the team buzz at once.
The third is that failures must speak up. Actions fail in three ways: the target is gone (the person to @ has left), permission is gone (the board the rule wants to touch is now read-only), or an external service is down (the email provider timed out). Every failure must leave one line in the rule's run log — when, which card, and why. After three consecutive failures, the rule's creator gets a notification. The worst automation is not the kind that fails, but the kind that fails silently: users believe the rule is running while it actually stopped three months ago and the work has been piling up.
Actions should also be graded by danger. Sending notifications, changing labels, and @-mentioning people are safe actions — configure and run. Deleting cards, clearing data, and emailing outsiders are dangerous actions: the first run needs a second confirmation, and the rule page must state in red that "this rule deletes cards". Keep dangerous actions out of beginner templates and open them up once users are experienced.
6. Permissions and safety: who can build rules, and whose data can rules touch
Rules work on the user's behalf, so a rule's power must never exceed its creator's. Baiyang Board's rule is simple: a rule can only touch what its creator is allowed to touch. A regular member's rule can only affect boards they participate in; only an admin's rule can affect the whole team. When someone leaves, their rules are either disabled automatically or handed to their successor — no orphan rule keeps running with nobody responsible.
Another permission trap is "the rule reads data for me". A rule like "when a customer pays, sync the order to the public board" is fine for its creator, who can see orders — but not everyone on the public board should see them. Once the rule runs, order information has leaked to people who shouldn't have it. The fix: any rule that moves data across boards or teams needs one admin approval, on a page that states plainly "this rule will send data from board A to board B, where 12 people can see it".
Creating, editing, disabling, and deleting rules all go into an operation log: who, when, what changed. The log needn't be visible to everyone, but admins must be able to look it up. When a rule causes trouble, the first thing to check is the log: who built this rule, when was it changed, and what did it look like before. Without a log, the post-mortem is guesswork.
7. When rules grow from three to thirty: list, switch, run log
Once rules grow from three to thirty, management becomes the new problem. Baiyang Board's rules list page shows only four things per rule: its name, a one-line description (trigger plus action), its switch, and when it last ran. The full trigger, condition, and action only appear after clicking into a rule. The list page avoids detail so users can see at a glance which rules are running, which are stopped, and which haven't run lately.
Every rule needs a switch, and switching off must take effect immediately. When the team goes on holiday, an admin turns off "nudge overdue tasks at 9 a.m. daily" with one tap and turns it back on when the holiday ends — far easier than deleting rules one by one and rebuilding them later. Next to the switch, the page shows how many times the rule ran in the last seven days, how many succeeded, and how many failed. A rule with zero runs gets a note — "not triggered in the last seven days" — reminding its creator to check whether the trigger is wrong.
The run log is the rule's health check. Baiyang Board's log records only four things: when, what triggered it, the action's result, and the failure reason. Logs are kept for the last thirty days and then cleared automatically — nobody reads older ones. Spend ten minutes a month scanning the run log: fix the rule with the highest failure rate, ask whether a rule untouched for three months is still needed, and merge duplicates. Rules, like code, grow weeds without weeding.
8. The rule execution chain: from trigger to time saved, plus a launch checklist
Put the previous seven sections together, and every rule follows the same chain from trigger to result: the trigger fires, the conditions filter, the action runs, and a run-log entry remains. Here is a set of invented example numbers to measure that chain: in one month at Baiyang Board, 1,000 triggers fired, 640 passed the condition filter, 628 actions executed successfully, and 12 failed and went into retry with a notice to their creator; those 628 successful actions saved the team about 96 hours of repeated work. These numbers are made up, to show that every link in the chain filters: conditions screen out what shouldn't run, failure handling catches what ran badly, and the hours saved are the rule's real output.

Once a rule is running, users must also be able to see it working. Baiyang Board's approach: every time a rule runs, it leaves one small line in the board's activity feed — "9:03, the rule 'Notify tester when done' @-mentioned A-Zhe on this card". While users work on the board, they can always see the rule working for them, and trust accumulates exactly like that. The reverse is also true: a rule that runs for a month and leaves no trace makes users doubt whether it ever ran, and sooner or later they switch it off. Automation you can see is automation you can trust. The same goes for the rules list page: "ran 14 times yesterday" next to a rule convinces far more than a hundred words saying "this rule is running normally".
Before launch, there is a short checklist worth ticking off one by one. First, one rule gets one trigger, and polling is never a trigger. Second, templates come first: three to six templates for new rules, and dangerous actions stay out of beginner templates. Third, actions are idempotent and rate-limited, three consecutive failures notify the creator, and run logs are kept for thirty days. Fourth, a rule's power never exceeds its creator's, cross-board data flows get one admin approval, and changes go into an operation log. Fifth, every rule has a switch and a seven-day run summary, and a rule untouched for three months gets asked whether it is still needed. Sixth, do the job by hand for two weeks before automating: things that happen fewer than twice a month, things whose judgment standard can't be stated, and things where one mistake costs dearly should not be automated yet. With those six done, automation rules are genuinely live, not just a switch in the settings menu that nobody dares to touch.
Comments (0)
Related articles
Flexbox lays things out in one direction at a time, and when it is done right, the nav bar, the card wall, and the cart rows all behave. This guide follows MDN's Basic concepts of flexbox, Aligning items in a flex container, and Controlling ratios of flex items along the main axis: the two axes, containers and items, direction and wrapping, free space, the three flex properties, alignment on both axes, and gaps and auto margins.
One order is one object: table, dishes, total, paid — all filed by label. This guide follows MDN's Working with objects, JSON, and Object references: object literals, dot vs bracket notation, adding and deleting properties, for...in with hasOwn, methods and this, getters and setters, references vs copies, Object.assign and friends, null-prototype objects, JSON's strict rules, and stringify and parse with their number-precision trap.
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.