This article covers advanced concepts that help you master complex automation scenarios and avoid common pitfalls.

Working with multiple automations

As soon as you start building multiple automations, problems can quickly arise - especially when multiple automations listen to the same signal: a new incoming message.

Understanding the problem

The different message triggers all listen to the same basic signal (an incoming message), just with different circumstances:

New incoming conversation: Circumstance: Must be the first message of a conversation AND come from the contact
Reopened conversation: Circumstance: Existing conversation has status "Done" AND contact sends new message (not when agent reopens)
Contact scans QR code / opens link: Circumstance: Essentially "New incoming message" + already prefilled message content
New incoming message: Circumstance: No further restrictions - every message triggers

When do problems arise?

The triggers above (New conversation, Reopened, QR code) are mutually exclusive because they have the filter already built into the trigger. They cannot fire simultaneously for the same message.

Problems only arise when you use "New incoming message". This trigger has no restrictions and can therefore always fire simultaneously with the other triggers.

Example: When things go wrong

You've built two automations:

Automation 1:

Trigger: "New incoming conversation"
Action: AI agent responds to the inquiry

Automation 2:

Trigger: "New incoming message"
Filter: Message contains "Help"
Action: Send help center link

What happens when a customer writes for the first time: "Help, I need support"?

Automation 1 triggers (new conversation) → AI agent starts responding
Automation 2 triggers simultaneously (message contains "Help") → Help center link is sent
Customer receives 2 messages at the same time - one from the AI agent AND the help center link
Customer is confused, communication seems uncoordinated

The problem: Both automations run in parallel and don't know about each other.

The solution: More general automation checks and yields

The best solution for this problem: Let the more general automation check if a more specific automation is already running. If yes → it stops itself.

In our example, Automation 1 is more general (only trigger, no further conditions), Automation 2 is more specific (trigger + filter "contains Help").

Here's how to build it:

Automation 1 (the more general one):

Trigger: "New incoming conversation"
Node "Wait / Pause": Wait 4 seconds
Node "Filter / Condition": Active automation
- Path 1: Contains none of "Automation 2" → Continue to AI agent
- Else: Automation stops (do nothing)
Node "AI Agent"

Automation 2 stays as it is (no changes needed)

What happens now?

Scenario 1: Customer writes "Help, I need support"

Both automations trigger simultaneously
Automation 2 starts immediately (filter "contains Help" → matches)
Automation 1 waits 4 seconds
After 4 seconds: Filter checks if Automation 2 is active → Yes, it's running
Automation 1 stops → Customer only gets the help center link

Scenario 2: Customer writes "Hello, I have a question"

Both automations trigger simultaneously
Automation 2 checks filter "contains Help" → doesn't match → stops immediately
Automation 1 waits 4 seconds
After 4 seconds: Filter checks if Automation 2 is active → No, it's no longer running
Automation 1 continues → Customer gets AI agent

Why wait 4 seconds?

Without the wait time, timing issues could occur - Automation 1 checks if Automation 2 is running before it has even started or checked its filters. The 4 seconds give Automation 2 enough time to start and run through its filters.

Important - The rule:

The more general automation (fewer filters, broader scope) should check and yield - not the more specific one. Why? Because the more specific automation is more targeted and should take priority in cases where it applies.

Remember for multiple automations

Problems with multiple overlapping automations are always solved with a combination of:

Node "Wait / Pause" - Gives other automations time to start
Filter "Active automation" - Checks which other automations are currently running
Node "End other automation" - Specifically ends other automations that shouldn't continue running

With these three tools you can handle any automation collision.

Working with omnichannel automations

An automation can run across multiple channels simultaneously. This means you can start communicating with a customer via WhatsApp in a single automation and then continue via email.

How does it work?

Example scenario:

Trigger: "Contact scans QR code" (WhatsApp)
Node "Ask question": "What's your email address?"
Node "Edit contact": Save email to contact
Now here's the trick: Node "Send message"

In the "Send message" node you normally have the field "To" prefilled with "Conversation from trigger". This means the message will be sent to the WhatsApp conversation.

But: You can instead select "To contact".

As soon as you do this, a new dropdown appears with only email and SMS as options (these are the only outgoing channels we support).

Select "Email" or "SMS", compose your message - and a second conversation is opened within the same automation.

Why no WhatsApp?

WhatsApp doesn't appear here because there's a dedicated node for it: "Send WhatsApp template". WhatsApp has stricter rules (24h window, only approved templates outside the window) - that's why there's a separate node. For email and SMS you use the regular "Send message" node.

What does this mean for your automation?

From the moment you've opened a second conversation, you have two parallel conversations:

The WhatsApp conversation (from the trigger)
The email conversation (from the "Send message" node)

Important: For all actions based on a conversation, you now need to select which conversation the action should be applied to.

Example: Update label

After the "Send message" node (email) you add an "Update label" node.

Before: Only one field "Label" - clear which conversation is meant (the one from the trigger)
Now: Additional field at the top: "Conversation" with dropdown:
- "Conversation from trigger" (WhatsApp conversation)
- "Conversation from email send" (email conversation)

You must explicitly choose which conversation you want to add the label to.

Which nodes are affected?

All nodes that work on conversations need the selection:

Update label
Mark conversation as done
Mark conversation as spam
Delete conversation
Move conversation to another inbox
Assign conversation
Create note

Example use case: Fallback for delivery problems

Scenario: You use a webhook trigger (e.g., from your e-commerce system) to notify customers via WhatsApp. But what if the contact doesn't have a WhatsApp number stored or isn't reachable on WhatsApp?

Automation setup:

Trigger: Incoming webhook (e.g., "Order placed")
Node "Send WhatsApp template": Send order confirmation via WhatsApp
Follow-up paths from WhatsApp template node:
- Error path: Message could not be delivered (e.g., because contact isn't on WhatsApp, etc.)
In the error path: Node "Send message"
- To: Contact
- Channel: Select email or SMS
- Compose the same order confirmation
Result: Customer is guaranteed to receive the notification - either via WhatsApp or as fallback via email/SMS

Automation variables vs. contact attributes

There are two types of data in automations: Automation variables and contact attributes. The difference is important.

The difference

Contact attributes:

Are permanently stored on the contact
Remain even after the automation ends
Can be used in other automations
Visible in the contact detail view
Examples: Name, email, phone, custom contact attributes

Automation variables:

Only exist while the automation is running
Disappear after the automation ends
Can NOT be used in other automations
Not visible outside the automation
Examples: Response from "Ask question", HTTP response, etc.

System variable: Current date / time

A particularly important automation variable is the system variable "Current date / time".

Why so valuable?

You can use it to store timestamps in contact attributes and later use them for timing logic.

Example: Track last manual handling

Create contact attribute "Last manual handling" (type: Date/time)
Automation with trigger "Conversation marked as done" → Update contact: Set "Last manual handling" to system variable "Current date / time"
Another automation with trigger "New/Reopened conversation" → Filter: "Last manual handling" is more than 30 minutes ago → If yes: To AI agent, If no: Directly to team

Nodes with output variables

Many nodes create automation variables after they are executed. You can use these in subsequent nodes.

All Message Triggers

Every message trigger (New incoming conversation, New incoming message, Reopened conversation, etc.) outputs the following variables:

Inbox name - Which inbox the conversation is in
Message content - What the customer wrote
Channel - Via which channel (e.g., "+491744839743", "test@superchat.de")

Webhook Trigger

Outputs all mapped variables that you defined in the trigger setup under "Saved variables".

Example:

Shopify sends order_id → You map to variable "order_number" → Use in message: "Your order {{order_number}} has been received"

Manual Trigger

If the manual trigger has input fields, these are output as variables. Additionally, the manual trigger also outputs the inbox name where the automation was triggered.

Example:

Input field "Discount code" → User enters "SUMMER20" → Use in message: "Here's your code: {{discount_code}}"

HTTP Request Node

Outputs the following variables:

Status code - As text (e.g., "200", "404", "500")
Response body - The entire response
Saved variables - All fields you mapped from the response under "Saved variables"

Example:

API returns {customer_name: "Max"} → You map to "customer_name" → Use: "Hello {{customer_name}}"

Format Data Node

Outputs the formatted result as a variable.

Example:

Input: "2024-05-20" → Transformation: Format to "May 20, 2024" → Variable contains "May 20, 2024"

All Message Nodes with Interaction

The following message nodes output the customer's response as a variable:

WhatsApp list - Which list item was clicked
WhatsApp quick responses - Which quick response was clicked
Live chat interactive - Which option was selected
Ask question - What the customer answered

Important: The variable contains either the selected button/item OR the free text if the customer wrote something else.

Example Ask Question:

You ask: "What's your name?"
Customer responds: "John Smith"
Variable contains: "John Smith"
Use in next node: "Thanks {{ask_question.response}}!"

Waiting for Reply Node

There is a special follow-up node "Wait for response" that also outputs the customer's response as a variable. This node can only be used in two specific places:

1. After the "Send message" node:

You can place "Wait for response" directly after any "Send message" node. The automation then pauses until the customer responds and outputs the response as a variable.

2. After the "WhatsApp template sent" trigger:

You can place "Wait for response" after this trigger, but only if the selected template contains no interactive elements (quick responses or list items). Call-to-action buttons are allowed, but no interactive message elements.

Why this restriction?

For templates with quick responses or list items, there are already automatic follow-up paths for each response option. The "Wait for response" node would be redundant and would lead to conflicts.

Output:

The node outputs the customer's response as a variable, just like the other message nodes.

More details:

This node is covered in detail in the article "Message nodes".