Connections & Branching

Connections are the lines between nodes that define the flow of conversation. They determine which node runs next and how the conversation branches based on customer actions.

How connections work

Single-output connections

Most nodes have one output — the conversation always continues to the next connected node.

Examples: Text Message, Media Message, Question, HTTP Call, Script

Multi-output connections

Some nodes have multiple outputs — the conversation takes different paths based on what happens.

Node type	Outputs
Interactive Buttons	One output per button (up to 3)
List Menu	One output per list row
Condition	TRUE and FALSE
Router	One per path + Default
Template Message	One per button (if template has buttons)

Creating connections

1. Hover over a node to see its output handle (small circle on the right)
2. Click and drag from the output handle
3. Drop it on another node's input handle (small circle on the left)
4. A line appears connecting the two nodes

📸

Screenshot: Dragging a connection from one node to another

creating-connection.png

1. In the Flow Builder, hover over a node output handle
2. Drag from the output to another node input
3. Capture the moment showing the connection being made
Save to: static/img/screenshots/chatbot-flows/connections/creating-connection.png

Deleting connections

1. Click on the connection line to select it
2. Press the Delete key

Edge labels

Connections from multi-output nodes automatically show labels to indicate which path they represent:

• Button connections show the button label (e.g., "Browse Products")
• List connections show the row title (e.g., "Sales Department")
• Condition connections show "TRUE" or "FALSE"
• Router connections show the path label (e.g., "VIP Customer")

Branching patterns

Pattern 1: Linear flow

The simplest pattern — one node after another, no branching.

┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐
│ Trigger │───▶│ Message │───▶│ Question│───▶│  End    │
└─────────┘    └─────────┘    └─────────┘    └─────────┘

When to use: Simple greeting bots, single-step notifications, data collection flows.

Pattern 2: If/Else branching

A Condition node splits the flow into two paths.

                           ┌── TRUE ──▶ ┌─────────┐
┌─────────┐    ┌──────────┐│            │ VIP Msg │
│ Trigger │───▶│Condition ││            └────┬────┘
└─────────┘    └──────────┘│                 │
                           └── FALSE ─▶ ┌────▼────┐
                                        │ Std Msg │
                                        └────┬────┘
                                             │
                                        ┌────▼────┐
                                        │   End   │
                                        └─────────┘

When to use: Yes/No decisions, eligibility checks, VIP vs standard routing.

Pattern 3: Menu branching

Interactive buttons or list menus create multiple paths based on the customer's selection.

                               ┌─── Button 1 ──▶ ┌─────────┐
┌─────────┐    ┌──────────────┐│                  │  Path A │
│ Trigger │───▶│  Buttons /   ││                  └─────────┘
└─────────┘    │  List Menu   │├─── Button 2 ──▶ ┌─────────┐
               └──────────────┘│                  │  Path B │
                               │                  └─────────┘
                               └─── Button 3 ──▶ ┌─────────┐
                                                  │  Path C │
                                                  └─────────┘

When to use: Main menus, department selection, product categories.

Pattern 4: Multi-level branching

Combining patterns — a menu leads to sub-menus or further conditions.

                                 ┌─── Sales ───▶ ┌────────┐──▶ ┌────────┐
┌─────────┐    ┌────────────┐   │                │Question│    │Qualify │
│ Trigger │───▶│   Main     │───┤                └────────┘    └────────┘
└─────────┘    │   Menu     │   │
               │            │   ├─── Support ──▶ ┌────────┐──▶ ┌────────┐
               └────────────┘   │                │  FAQ   │    │ Agent  │
                                │                │  Menu  │    │ Assign │
                                │                └────────┘    └────────┘
                                │
                                └─── Billing ──▶ ┌────────┐──▶ ┌────────┐
                                                 │Invoice │    │  End   │
                                                 │ Lookup │    │        │
                                                 └────────┘    └────────┘

When to use: Complex customer service bots, multi-department routing, product recommendation flows.

Merging branches

Multiple paths can merge back into a single node. For example, after handling different button responses, all paths might lead to the same "Thank you" message or End node.

Simply connect multiple nodes to the same target node. The target node runs whichever path reaches it.

┌─────────┐ ─── Path A ──┐
│ Button 1│               │
└─────────┘               ▼
                    ┌─────────────┐
┌─────────┐ ─── Path B ──▶│  Thank You  │──▶ ┌─────┐
│ Button 2│               │   Message   │    │ End │
└─────────┘               └─────────────┘    └─────┘
                          ▲
┌─────────┐ ─── Path C ──┘
│ Button 3│
└─────────┘

Best practices

Practice	Why
Keep branching shallow	Deeply nested branches are hard to read and maintain
Use Router for 3+ paths	Instead of chaining multiple Conditions, use a single Router node
Label your connections	Edge labels make the flow easier to understand at a glance
Merge branches when possible	Avoid duplicating the same logic in multiple paths
Add End nodes	Every path should eventually reach an End node to close the conversation properly
Test each path	Use manual triggering to test every possible path through the flow