Flow: automations
An automation is a rule that Flow runs on its own: when something happens to an object, the rule checks a condition and performs actions. For example, it tells an assignee they were assigned; unblocks a task once all its blockers are closed; creates an onboarding project when a deal is won; or moves overdue tickets once a day on a schedule.
Automations are set up separately for each object type. This article covers the editor and the run log. The rule format for integrations is described in Flow API: automations, reminders and expressions.
Where to set them up
Open Settings → "Types and fields", choose a type and the "Automations" tab. The tab has two modes:
"List" — the type's automations: name and short description, the "on / off" switch, the "unpublished" and "draft" marks, and the status and time of the last run. Buttons: "Edit" (or "Open" if you have no permission to edit) and "Runs".
"Run log" — the execution history, described below.
The "New automation" button creates a new rule. It is visible to those with permission to manage the type's automations (automation.manage). Any member with permission to read automations can view the list.
How a rule works
The editor has three steps:
"When" — the event the rule fires on (the trigger) and its refinements.
"If" — the condition. Optional, except for the "Condition became true" trigger.
"Then do" — from 1 to 20 actions. They run in order; you change the order with the ↑ and ↓ arrows.
Above the steps are "Name", "Key" (the machine name, which can't be changed after saving) and "Run as".
Whom the rule runs as
Actions are performed by a service executor, not by the person who changed the object. The executor's permissions apply during the run. Every workspace gets an "Automations" service executor with the system integration role when it is created — the editor suggests it by default. Only someone with permission to manage the workspace can set a different service member as the executor.
So a rule can do things the author of the change can't, and vice versa: if the executor has no permission for an action, the run ends with an error.
Draft and publishing
A rule is stored in versions. "Save draft" keeps your changes but doesn't turn them on. "Publish" checks the whole rule: the condition, fields, statuses, transitions, relations and recipients. All errors found are shown at once next to their fields, with line and column numbers for expressions. If there are warnings, the rule is published, and the editor shows a "Published with warnings" block.
Once published, the new version applies to all objects of the type immediately. A rule can have only one draft.
"When": events
Event in the editor | When it fires | Refinements |
|---|---|---|
Object created | once for each new object | — |
Fields changed | the object's data changed | "Only when these fields change": fires if at least one of the selected fields changed |
Status changed | the object moved to another status | "To status", "From status", "By transition" |
Object archived | the object was archived | — |
Object restored | the object was restored from the archive | — |
Condition became true | the condition from the "If" step became true: it was false, or the object is new | the condition is required |
Relation added | the object gained a relation | "Relation" and "This object in the relation" (source or target) |
Relation removed | a relation was removed | same |
On schedule | on a cron schedule | "Cron", "Time zone", object filter |
Reminder fired | a deadline reminder from the "Reminders" tab fired | the reminder rule key and offsets (JSON) |
External event | an integration sent an event through the API | "External event type", "Source" |
Process event | the object's process started, passed a step, finished, failed or was cancelled | "Events", "Process", "Step" |
On schedule
The schedule is a five-field cron expression (minute, hour, day of month, month, day of week), for example 0 9 * * 1-5 — at 9:00 on weekdays. @daily, @weekly and other shorthands are supported. A schedule never fires more often than once every 5 minutes. The time zone is an IANA name, for example Europe/Moscow; by default the editor fills in the browser's time zone.
The "Which objects" field decides how the rule runs:
empty — a single run without an object. The condition is then unavailable, and the only actions allowed are "Create object" (without a relation or expressions), "Call webhook", "Send notification" and "Send email";
a filter
{"where": …}— the rule runs for each matching object of the type, and the condition is checked for each one. No more than 10,000 objects are processed per slot (a workspace quota).
A time skipped by the switch to daylight saving time runs once, shifted; a repeated time runs once. After a service outage, only the last missed slot runs.
Condition became true
This trigger watches a condition and fires at the moment it turns from false to true. An example from the "Tasks" template: state.key == 'blocked' && can_transition('unblock') — the task is blocked, but all its blockers are already closed. Flow re-evaluates conditions with deadlines (now > data.due_date + duration('P1D')) over time on its own; the allowed forms are described in the API article.
"If": the condition
A condition is written in the Flow expression language:
data.field— a field's value:data.amount.amount > 100000;state.keyandstate.category— the status and its category:state.category != 'done';changed('field')— whether the field changed in this operation;can_transition('key')— whether the transition is allowed right now;relations.relation.any(x, …)— a condition on related objects.
If you'd rather not write expressions, open "Add a condition without expressions": it offers "field equals", "field doesn't equal", "field is filled", "field is empty", "status" and "transition allowed". The "Add" button appends the condition with &&.
If the condition is false, the run is marked "skipped" with the reason "condition false". An evaluation error (for example, division by zero) doesn't perform the actions: the run is skipped with the reason "error in condition".
"Then do": actions
Action | What it does |
|---|---|
Change fields | writes a value, computes it with an expression, or clears the field |
Move to status | runs a process transition, checking the transition's conditions; you can set a "Transition comment" and the transition form's values |
Create object | creates an object of any type; you can link it to the rule's object right away ("Link to this object") |
Link | adds a relation to another object (chosen or from an expression) |
Remove relation | removes a relation to another object |
Assign | changes the object's assignee |
Send event | emits a |
Call webhook | an HTTPS POST, PUT or PATCH request to your URL with your own headers |
Send notification | a message to selected members in Sensever chat |
Send email | an email to selected workspace members at their Sensever account address — see below |
Start process | starts a process of this type for the object; repeating the action doesn't create a second instance |
For each related object | runs nested actions on each related object that meets the condition (no more than 200 objects) — see below |
All actions except "For each related object" run on the object the rule fired on (the triggering object). Actions inside Flow (fields, statuses, relations, objects) run exactly once. Webhooks, notifications and emails are "at least once": they are retried if the connection fails. A repeated notification or email doesn't create a second message, and a webhook gets an Idempotency-Key header your server can use to discard the repeat.
A webhook URL must be https only, with a domain name or a public IP; internal network addresses and a login and password in the URL are forbidden. A response taking longer than 10 seconds counts as an error.
For each related object
This action goes through the objects related to the triggering object and does the same thing to each. Examples: "sprint closed — unfinished tasks move to the next sprint", "deal won — all its activities are closed".
Action settings:
"Related objects" — the triggering object's relation to take objects from: for example, "Tasks" on a sprint or "Activities" on a deal.
"Condition for the object (optional)" — an expression checked separately for each related object. In it, the related object is
x:x.data.field,x.state.key,x.state.category. The triggering object's fields are available as usual:data.field. Example:x.state.category != 'done'— only unfinished ones. Without a condition, the action applies to all related objects."What to do with each" — from 1 to 10 nested actions: "Change fields", "Move to status", "Assign", "Link", "Remove relation". Fields, statuses and transitions for nested actions come from the related objects' type.
In nested "Link" and "Remove relation", the second object can be chosen like this:
Option | What it is |
|---|---|
"select" | A specific object |
"expression" | An expression that returns an object id |
"triggering object" | The object the automation fired on, for example the closed sprint |
"related to the triggering object" | The single object related to the triggering object through the chosen relation, for example its next sprint. If there is no such object or there are several, the action on that object ends with an error |
Nested "Assign" has an "owner of the triggering object" option.
Example: moving unfinished tasks to the next sprint. You need a "Sprint" type with a "Tasks" relation (the sprint's tasks) and a relation from a sprint to itself, "Next sprint" ("one to one"). The rule in the "Sprint" type settings:
"When": "Status changed", "To status" — "Closed".
"Then do": the "For each related object" action, "Related objects" — "Tasks".
"Condition for the object":
x.state.category != 'done'.The first nested action is "Remove relation": the task's relation to the sprint, second object — "triggering object".
The second nested action is "Link": the same relation, second object — "related to the triggering object", relation "Next sprint".
When you close a sprint, each of its unfinished tasks is unlinked from it and lands in the next sprint. Finished tasks stay in the closed sprint.
How the action runs:
There can be no more than 200 related objects. If there are more, the action ends with an error without changing anything. For large sets, build the rule on the related objects' type or on a schedule.
Each object is processed separately, with the rule executor's permissions. An error on one object doesn't undo changes to the others.
An archived object, or one the executor can't see, is skipped.
If at least one object couldn't be processed, the action gets the "error" status. Changes to the successful objects are kept. "Retry" processes only the remaining objects and leaves the already processed ones alone.
The action is available in automations with a triggering object. It isn't available in a scheduled rule without a filter or in process steps.
Notifications: to whom and how
The "Send notification" action has "Recipients" (up to 100), "Title" and "Text". A recipient can be:
a specific member;
a system role: owner, administrator, member, viewer — or a custom workspace role;
an object field with people, such as "Assignee" or "Watchers";
the object's assignee or author.
The notification arrives in Sensever chat, in the "Sensever Flow" conversation, with a link to the object. The title and text are plain text, without expressions; field values aren't included in the notification. The recipient must have access to the object at the moment of sending; if they turned off automation notifications in their settings, the message won't reach them. If the recipient turned on the "Email" channel for the "Automations" category in their notification settings, they also get a copy by email. Learn more in Flow: notifications and reminders.
We don't notify the author. The person whose action caused the event doesn't get a notification about it: someone who closed a task themselves doesn't need a "Task completed" message. If the author does need the message, check "Also notify the author of the change". Changes made by an automation, a process, a schedule or a reminder have no author — all selected recipients get the notification.
Emails: the "Send email" action
The "Send email" action has the same form as a notification: "Recipients" (up to 100), "Email subject" (up to 200 characters), "Text" and the "Also notify the author of the change" checkbox. The email goes to the recipient's Sensever account address, with a link to the object.
Workspace members only. Recipients are chosen the same way as for a notification: a member, a role, a field with people, or the object's assignee or author. You can't enter an arbitrary email address.
The same checks as for a notification: the author of the change is excluded (unless the checkbox is checked), the recipient must be active and able to see the object, and turned-off notifications for the workspace or the "Automations" category (or this rule) cancel the email too.
The recipient doesn't need to turn on the "Email" channel in their settings — the rule itself requests the email. But if the person turned off "Email notifications" or unsubscribed via the link in an email, the email won't arrive.
The email isn't sent right away. Emails to one person are combined into one — no more than once every 15 minutes, and during their quiet hours, after those hours end. Access to the object is checked again before sending.
Emails go only to a verified account address. If someone has none, there is no email.
More about Flow emails in Flow: emails and calendar subscription.
Run log
The "Run log" tab (or the "Runs" button on a rule) shows every run: time, automation, object and status. You can filter by automation ("All automations of the type" or a single one) and by status.
Status | What it means |
|---|---|
queued | the run is waiting for an executor |
running | actions are being performed |
done | all actions were performed |
skipped | no actions were performed; the reason is shown alongside: "condition false", "condition didn't become true", "outdated event", "error in condition", "automation off", "object not found", "object archived" |
error | one of the actions failed; the following actions weren't performed |
"Details" expands the run's actions: the status of each ("done", "error", "attempts exhausted", "skipped"), the number of attempts and the error text. For notifications and emails you see how many were delivered, how many emails were queued ("by email: …") and why someone was skipped: "action author", "turned off by recipient", "no access to object" and other reasons. For "For each related object" you see the counters "objects: …, done: …, skipped: …, errors: …" and a list of objects that were skipped (with the reason: "condition false", "object archived", "no access to object") or not processed (with the error text).
Flow retries temporary failures (timeout, 5xx response, 429) on its own — up to 5 attempts with a growing pause of up to 10 minutes. Permanent errors (transition conditions rejected, no permission, 4xx response) stop the run immediately. You can "Retry" a failed run: the retry continues from the failed action, and actions already performed aren't repeated.
Loop protection
A rule's actions are also changes to an object and can trigger other rules. The chain stops if a rule appears in it again (A → B → A) or the chain depth reaches 5. Such runs aren't performed.
Built-in template rules
In a new workspace created from a template, rules that need no setup are already turned on:
Template | Rule | What it does |
|---|---|---|
Tasks |
| moves a task out of "Blocked" when all its blockers are closed |
Tasks |
| tells the assignee and watchers that the task is unblocked |
Tasks, Main |
| "You were assigned" |
Tasks, Main |
| "Task completed" — to the task's author and watchers |
CRM |
| when a deal is won, creates a linked "Onboarding" project and notifies owners, administrators and watchers |
CRM |
| a notification to the deal's new assignee |
CRM |
| a webhook to an external system; turned off and kept as a draft until you specify the URL |
Product development |
| moves a product to "Ready for production" once that becomes possible |
You can turn any of them off with the switch in the list or change it in the editor. Workspaces created earlier don't change: an administrator turns the rule on.
Besides automations, templates include deadline reminder rules (the "Reminders" tab of the same type): in "Tasks" and "Simple tasks" — for the task deadline, in CRM — for the deal's close date, and in "Product development" — for the planned release date. Which moments and to whom are described in Flow: notifications and reminders. About templates — in Flow: workspaces and templates.
What's next
Flow: notifications and reminders — personal notification settings and deadline reminders.
Flow: processes and approvals — multi-step processes started by the "Start process" action.
Flow API: automations, reminders and expressions — the rule format and the full expression language reference.
Komen