Task automations
One sentence per rule: when this task reaches a status, put someone on it, tell someone, or message the client. Write it on a task or on a task template, and it travels with every job made from it.
A flow moves a whole engagement. A task automation is much smaller and much more common: something should happen when one task changes hands.
The review task is finished, so the partner should know. The task moves to waiting-on-client, so the client should get a note. The task is marked in progress, so the junior who does the next bit should be on it. None of these are hard. All of them get forgotten.
One sentence, two picks
Every automation is a single sentence — When it becomes a status, Then do one thing:
- Open the task, or the task template, and find Automations.
- Add automation.
- Pick the status it has to reach. These are your firm's own statuses, shown with their colours — the same pills you click on the task itself.
- Pick what happens: Put someone on it, Notify someone, or Message the client.
- Choose who, or write the message, and Add.
The finished rule reads back at you in plain English, so a rule you wrote in March still makes sense in September.
The three things it can do
- Put someone on it — adds a person to the task. Added, not swapped: whoever is already on it stays.
- Notify someone — tells them, without making it their job. The right choice for a partner who wants to know a review finished, not to inherit it.
- Message the client — posts your words into the client's message thread, and they get the usual "you have a new message" email. Not a Vylan-worded notice: the message is yours.
The client message is a real message to a real client, sent with nobody watching. Write it so it reads correctly whenever it lands, and remember it goes to every client whose job runs this template.
Want two things to happen? Add two rules
One automation does one thing. If finishing a task should both notify the partner and message the client, that is two automations sitting one under the other — not one rule with a list inside it.
That is deliberate. A rule that can hold three actions needs a paragraph to describe itself, and a paragraph is not something you can read at a glance six months later.
On a template, or on one task
Written on a task template, the rules are copied onto every task created from it. Written on one task, they apply to that task alone.
Copied is the important word. Editing a template never reaches back into jobs already under way — a rule you change today applies to the next job, not to the one your colleague is halfway through. It is the same promise the tasks themselves make.
When they fire
A task automation runs when a person moves the task onto that status — ticking the checkbox, or picking a status by name. Rules written against the plain moment ("when it's completed") catch both; a rule pointed at one named status fires only for exactly that one.
They run as you, with your permissions, at the moment you make the change. Nothing fires overnight and nothing fires on a timer.
What they deliberately cannot do
A task automation cannot move the engagement to another stage. That question already has an owner — the flow decides when its stage advances, including on all its tasks being done — and a second control able to disagree with the first is worse than no control, because nothing on screen would tell you which one won.
Remove one with Remove automation. If a rule points at a status your firm has since deleted, Vylan says so in place rather than firing something you can no longer read.