IO node management

Node types

The node type determines what function the node performs within the flow. For a full reference of all available node types, see IO node types.

• Frontend (FE) nodes display data on forms and pages, and collect user input

• Backend (BE) nodes execute server-side logic and API calls

• Decision nodes control flow routing, evaluate conditions, and branch execution paths based on variables

• Integration nodes connect to external services and APIs

Settings

Nodes support various configuration options:

General settings

• Node name: Unique name for the node

• Node ID: Unique identifier for the node, auto-generated, used in the database, and cannot be changed

• Execution type: Frontend (runs in a browser) or backend (runs on a server)

Node settings

• Input settings: Data required by the node, variable references, default values, and validation rules

• Processing settings: Logic configuration, API endpoints, and transformation rules

• Output settings: Variables to store, output connectors, success/failure paths, and the data to pass forward

Node connections

• Input connectors: Typically one per node, on the left side. They accept data from previous nodes.

• Output connectors: Typically multiple outputs, on the right side. They are named by function (success, failure, and so on) and provide routing options to the next nodes.

Variable management

Variable scope

Node variables

• Produced by individual nodes

• Available to subsequent nodes

• Referenced using {{variable}}

Flow variables

• Shared across entire flow

• Set at flow start

• Persistent throughout execution

Session variables

• Stored in Redis cache

• Available for flow duration

• Cleared when flow ends

Variable naming

Best practices:

• Use descriptive names: userEmail not var1.

• Follow naming conventions: camelCase or snake_case.

• Avoid special characters.

• Keep names concise but clear.

Variable usage

Access variables in nodes:

{{variableName}}          # Simple variable
{{object.property}}       # Object property
{{array[0]}}             # Array element
{{user.profile.email}}   # Nested property

Common node patterns

Sequential processing

Nodes execute one after another:

[Node A] → [Node B] → [Node C] → [End]

Conditional branching

Flow splits based on conditions:

[Node A] → [Condition] → Success → [Node B] → [End Success]
                       → Failure → [Node C] → [End Failure]

Parallel options

Multiple paths available to user:

[Start] → [Option A] → [Process A] → [End]
        → [Option B] → [Process B] → [End]
        → [Option C] → [Process C] → [End]

Error handling

Catching and handling errors:

[Node A] → Success → [Node B] → [End Success]
         → Failure → [Error Handler] → [End Failure]

Advanced node usage

Custom logic

Some nodes support custom code:

• JavaScript execution

• Data transformation

• Complex validations

• Custom integrations

External integrations

Connect to external systems:

• REST APIs

• SOAP services

• Database queries

• Third-party platforms

Dynamic behavior

Configure nodes dynamically:

• Variable-based routing

• Conditional execution

• Runtime configuration

• Context-aware processing