Node management

Nodes are the fundamental building blocks of flows in Identity Orchestrator (IO). This section provides comprehensive guidance on working with nodes to create powerful workflows.

What is a node?

In Identity Orchestrator (IO), a node represents a single, self-contained step within a flow. Each node performs a specific function, such as user input collection, validation, decision making, integration with external systems, or execution of custom logic, and passes the result to the next node in the flow.

By connecting nodes together, IO enables the visual design and orchestration of complete identity and access processes.

How nodes work

Nodes are connected through outputs and inputs that define the execution path and data flow through the workflow.

Each node:

1. Receives input: Gets data from previous nodes or the flow context

2. Processes: Performs its specific function (display form, validate data, call API, and so on)

3. Produces output: Generates results and routes to next nodes

4. Updates context: Stores variables for use by subsequent nodes

Node Structure

Node Overview

Understand node components:

• Node name and identification

• Node type classification

• Frontend vs Backend execution

• Input and output connectors

• Node sizing and display

Node types

Frontend (FE) nodes

Execute in the user's browser:

• Display user interfaces.

• Collect user input.

• Render forms and pages.

• Show information to users.

Backend (BE) nodes

Execute on the server:

• Process data and logic.

• Call external APIs.

• Perform validations.

• Execute business rules.

Decision nodes

Control flow routing:

• Evaluate conditions.

• Branch execution paths.

• Route based on variables.

• Implement business logic.

Integration nodes

Connect to external systems:

• HTTP requests

• API calls

• Database operations

• Third-party services

Node operations

Add node

Learn how to add nodes to flows:

• Open the node palette.

• Search for specific nodes.

• Drag and drop nodes.

• Connect nodes together.

• Disconnect nodes.

Copy node

Duplicate nodes efficiently:

• Copy individual nodes.

• Replicate configurations.

• Save time on similar nodes.

• Maintain consistency.

Delete node

Remove nodes from flows:

• Select nodes to delete.

• Handle connected nodes.

• Clean up connections.

• Verify flow integrity.

Comment nodes

Document your flows:

• Add comments to nodes.

• Group nodes with comments.

• Improve readability.

• Document complex logic.

Manage variables

Work with node variables:

• View all flow variables.

• Copy variable names.

• Understand variable scope.

• Use variables in nodes.

Node configuration

Each node has configurable properties:

Common properties

Node Name

• Displayed on the flow canvas

• Should be descriptive

• Can be edited via pencil icon

• Helps identify node purpose

Node ID

• Unique identifier

• Auto-generated

• Used in database

• Cannot be changed

Execution Type

• Frontend (FE): Runs in browser

• Backend (BE): Runs on server

• Determines where logic executes

Node settings

Different nodes have specific settings:

Input settings

• Data required by the node

• Variable references

• Default values

• Validation rules

Processing settings

• Logic configuration

• API endpoints

• Transformation rules

• Conditional logic

Output settings

• Variables to store

• Output connectors

• Success/failure paths

• Data to pass forward

Node connections

Input connectors

Located on the left side of nodes:

• Receive execution flow

• Accept data from previous nodes

• Single input per node (typically)

Output connectors

Located on the right side of nodes:

• Direct flow to next nodes

• Provide routing options

• Multiple outputs possible

• Named by function (Success, Failure, and so on)

Connection rules

1. One input, multiple outputs: Most nodes have one input and multiple outputs.

2. Connect outputs to inputs: Link output of one node to input of another.

3. All outputs must connect: Ensure every output goes somewhere.

4. No circular references: Avoid creating loops (unless intentional).

5. End nodes required: All paths must end at an End node.

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]

Node best practices

Design principles

1. Single responsibility: Each node should do one thing well.

2. Clear naming: Use descriptive node names.

3. Consistent style: Follow naming conventions.

4. Minimal complexity: Keep node logic simple.

5. Reusability: Design nodes for reuse in library flows.

Configuration tips

1. Use variables: Reference variables instead of hardcoding values.

2. Validate input: Check data before processing.

3. Handle errors: Plan for failure scenarios.

4. Document settings: Add comments explaining complex configurations.

5. Test thoroughly: Verify node behavior in isolation.

Connection guidelines

1. Connect all outputs: Don't leave outputs dangling.

2. Use appropriate paths: Connect success to success, failure to failure.

3. Minimize crossing lines: Keep flow layout clean.

4. Group related nodes: Use comments to organize.

5. Test all paths: Verify each connection works correctly.

Node performance

Optimization

1. Reduce node count: Combine operations when possible.

2. Minimize API calls: Batch requests or cache results.

3. Optimize conditions: Order conditions by likelihood.

4. Use appropriate node types: Choose efficient node implementations.

5. Avoid redundancy: Don't repeat operations.

Monitoring

Track node execution:

• Execution time per node
• Success and failure rates
• Variable values at each step
• Error messages and logs

Troubleshooting IO nodes

Common node issues

Node won't save

• Check that required fields are filled.

• Verify that variable names are valid.

• Ensure that output connectors are configured.

Node doesn't execute

• Verify that the input connection exists.

• Check that node is reachable in the flow.

• Review node configuration.

Variables not available

• Confirm that the previous node set the variable.

• Check the variable name spelling.

• Verify the variable scope.

Node execution errors

• Review error messages in logs.

• Check API endpoint availability.

• Validate the input data format.

• Verify credentials and permissions.

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

Next steps

Explore node operations in detail:

• Add node: Add nodes to flows.

• Node overview: Understand node structure.

• Manage variables: Work with variables.

• Flow design: Build complete flows.