Creating and Managing Boards

Introduction

Boards are the heart of IONFLOW. A Board is the visual workspace where you design, test, and manage your automations. Inside each Board you can create one or several Flows — sets of connected nodes that represent processes with their own logic, triggers, and outcomes.

Think of a Board as a project that groups all flows related to a business goal. For example, a Board called “Email Marketing” could contain a Flow that receives incoming emails and classifies them, another that generates personalized responses with AI, and another that sends weekly reports.

Everything is built without writing code, by dragging nodes onto the canvas and connecting them visually. For advanced users, IONFLOW offers a powerful commands and expressions system that allows data transformation within nodes.

Who is This Section For

Business operators: Who need to create simple automations without technical expertise
Process specialists: Who design complex flows with conditional logic and loops
Power Users: Who leverage versioning, scripting, and subflows for advanced solutions

What is a Board?

A Board is your automation canvas. Its main characteristics are:

Visual drag-and-drop editor
No limit on nodes or flows within a Board
Nodes are connected with lines (edges) to define data flow and execution order
Versioning system with saved states, separate drafts, and change history
Two execution modes: Dev (visual preview) and Live (automatic production)
Identified by name and description (currently no folders or tags)

Note: Nodes that aren’t connected to any flow simply do nothing — they don’t generate errors when saving.

Accessing Boards

Log in to IONFLOW
In the left sidebar, click Boards
You’ll see the list of all your boards with their name, description, and status (active/inactive)
Use + Create Board to create a new one, or click the edit icon (✏️) to open an existing one

Creating a New Board

Click + Create Board in the top right corner
Enter a descriptive name (e.g., Shopify-Inventory Sync)
Optionally add a description of the board’s purpose
Click Create
The visual editor will open with an empty canvas ready for design

Board Components

Nodes

Nodes are the building blocks of your flows. Each node has a specific task and is configured through a sidebar panel with forms.

Nodes are divided into three categories:

Basics

Node (UI Label)	Description
Scheduler	Schedule-based trigger. Executes the flow automatically at a defined interval. JSON: `ion.trigger.scheduler`
HTTP Request	Makes HTTP requests to any REST API. Configure URL, method, headers, and body. JSON: `ion.action.http`
Webhook	Trigger that fires when an external application sends data to a URL generated by IONFLOW. JSON: `ion.trigger.webhook`
Webhook Response	Sends a custom response to the service that fired the webhook. JSON: `ion.action.webhook_response`

Tools (Logic Control)

Node (UI Label)	Description
Simple Decision	Binary evaluation (true/false). If all conditions are met, takes the `then` output; if any fails, takes the `false` output. JSON: `ion.action.condition`
Multiple Decision	Multiple routing (N paths). Each rule creates a different output, with a `default` path when none matches. Ideal for classifying data. JSON: `ion.action.switch`
Form	Collects user data through a structured form. JSON: `ion.action.form`
Mapper	Visual data transformation. Allows restructuring information before passing it to the next node. JSON: `ion.action.mapper`
Iterator	Loops through array elements one by one (sequential). Each element is processed as an independent execution. JSON: `ion.action.iterator`
Timer	Introduces an execution delay (maximum 15 minutes). Useful for respecting external API rate limits. JSON: `ion.action.timer`
Call Component-Flow	Executes a subflow (flow within a flow). Allows reusing logic already built in other boards. JSON: `ion.action.flow`
On Call Component-Flow Trigger	Trigger that fires when another flow calls this one as a component. JSON: `ion.trigger.flow`

Persistent Data (Storage)

Node (UI Label)	Description
Persistent Data Save	Create a new record in the Data Store. JSON: `ion.store.add`
Persistent Data Get	Read a record by its key. JSON: `ion.store.get`
Persistent Data Update	Update an existing record. JSON: `ion.store.update`
Persistent Data Delete	Delete a record. JSON: `ion.store.delete`
Persistent Data Check	Verify if a record exists. JSON: `ion.store.check`
Persistent Data Search	Query records with filters. JSON: `ion.store.search`
Persistent Data Count	Count records matching criteria. JSON: `ion.store.count`
Persistent Data Delete All	Delete all records from a table. JSON: `ion.store.delete_all`

App Nodes (Integrations)

These are nodes specific to each application registered in IONFLOW (Shopify, FedEx, Gmail, Slack, etc.). They are dynamically configured based on the application and its available modules.

About error handling: There is no dedicated “Error Handler” node. Instead, all nodes have an output handle called error that you can connect to handle failures individually.

Connections (Edges)

Connections are the lines that join nodes together. They determine:

Data flow: the output of one node becomes the input of the next
Execution order: nodes execute following the direction of the connections
They connect from the output port (right side of the node) to the input port (left side of the next node)

Node IDs

Each node receives a unique automatic ID generated by the visual editor (e.g., $51, $52, n_1744393764259). Users don’t define these IDs manually.

Control Logic

Simple Decision (Binary)

The Simple Decision node evaluates one or more expressions and produces two paths:

                           ┌── then ──→ [Action if true]
[Data] → [Simple Decision]
                           └── false ──→ [Action if false]

Multiple Decision (N Paths)

The Multiple Decision node allows routing data through N different paths, ideal for classifications:

                              ┌── pending ───→ [Process Pending]
                              │
[Data] → [Multiple Decision] ┼── shipped ───→ [Track Shipment]
                              │
                              ├── cancelled ─→ [Refund]
                              │
                              └── default ───→ [Unknown Status]

The Multiple Decision node has two operation modes:

Rules: Visual rule builder (no code)
Expression: Custom expression evaluation using the commands language

Iterators (Loops)

The Iterator node loops through array elements sequentially (one by one). Each element is emitted as a separate entry in the execution queue.

[Array of orders] → [Iterator] → [Process each order individually]

Context and References Between Nodes

One of IONFLOW’s most powerful features is the ability to reference data from any previous node in the flow, not just the immediately preceding one.

How It Works

When you open a node’s configuration, you can place your cursor in any text field. A pop-up with information from all previously executed nodes will appear. Simply drag the reference to the field where you need it.

Reference Patterns

Pattern	Description
`{{$1}}`	Complete data from the node at position 1 in the stack
`{{$1.field}}`	Specific field from the node at position 1
`{{n_1.response}}`	Direct reference by node name/ID
`{{toBase64(value)}}`	Built-in functions applied to the value

References are resolved using the execution stack, which stores the complete history. This means you can access data from any previous node in the chain.

Note on global variables: The flow data structure includes a variables field for future global variables, but this feature is not yet implemented. Currently everything is passed from node to node via the stack.

For more information on available operations and transformations, see Command Definitions.

Visual Editor (Board Canvas)

The visual editor consists of:

Central canvas: The main area where you drag and connect nodes
(+) Button: To add new nodes to the canvas
Sidebar panel: Opens when you click a node to configure its parameters
Bottom bar: Shows the flow name, active draft (e.g., main), and action buttons

How to Use the Editor

Click the + button or drag a node from the library
Click a node to configure its parameters in the sidebar
Connect nodes by dragging a line from the output port to the input port of the next one
Use the context pop-up to reference data from previous nodes
Save with Save when you’re done

Board Versioning

IONFLOW includes a versioning system that lets you manage changes professionally. The concepts are similar to version control systems like Git, but with its own terminology.

Available Operations

Action in the interface	Description	Git Equivalent
Save	Saves the current state of the board with a descriptive message. Each save is recorded as a “Saved State” with date and hash.	Similar to a commit
Separate Drafts	Creates parallel versions of the board to work without affecting the main one.	Similar to creating branches
History	Shows the list of all saved states (Saved States), with their message, date, and hash. Allows comparing the saved state with current changes (Board Diffs, Code Diffs).	Similar to git log
Discard Changes	Discards current changes and reverts to the last saved state.	Similar to git checkout / git restore

Separate Drafts

In the editor’s bottom bar you’ll see the active draft name (e.g., main) and the flow name. You can create separate drafts to:

Experiment with changes without affecting the production version
Work on improvements while the main flow keeps running
Maintain separate test versions

History and Comparison

When you open History, you’ll see the Board Saves screen with:

List of Saved States: Each shows the message, date, and an identifying hash
Available Separate Drafts: Dropdown selector to view saved states for each draft
Board Diffs: Visual comparison between the saved board and current changes
Code Diffs: JSON code comparison between the saved state and the current one

Testing Boards (Preview)

Before activating a board, always test it in Dev (Preview) mode:

Click the Preview button in the bottom bar
The board executes once in visual mode
You can see data flowing between nodes in real-time
Use pause, resume, and stop controls to debug

⚠️ Important: Preview mode makes real calls to external APIs. There is no mock or simulation mode. If you need to avoid side effects (like sending real emails), configure your connections to point to the corresponding API sandbox.

Difference Between Dev and Live

Mode	Description
🛠️ Dev (Preview)	Visual execution in the editor. You can see data at each node in real-time, pause and resume.
🚀 Live (Active)	Background execution. The flow runs automatically according to its trigger (schedule or webhook) without user intervention.

Exporting and Importing Boards

IONFLOW allows exporting and importing boards as JSON files:

Export: Downloads the complete board as a .json file
Import: Loads a board from a .json file

This functionality also serves to clone boards: export an existing one and import it as a new one.

📋 A dedicated “Duplicate Board” button is planned for future versions.

Active vs Inactive Boards

Status	Description
Active (ON)	The board runs automatically according to its trigger. The toggle is blue.
Inactive (OFF)	The board doesn’t run. You can edit and test it without it activating.

To change the status, use the toggle in the boards list or in the top corner of the editor.

Common Errors

Error	Cause	Solution
”Board not running”	Trigger not configured or board inactive	Verify the trigger is configured and the toggle is ON
”Data not passing between nodes”	Incorrectly referenced variable or wrong data type	Use the context pop-up to verify references. Check that data types match (string vs number)
“Node not appearing in library”	Application (Grapp) not installed or missing connection	Create the connection first in the Connections section, or use HTTP Request as an alternative
”Connection not authorized”	Expired OAuth token	Go to Connections and click Re-authorize

Key Terms

Board: Workspace that groups one or several related flows
Flow: Set of connected nodes representing a process with start and end (can have multiple of both)
Node: Individual block that performs a specific task (condition, transformation, API call, etc.)
Edge (Connection): Line connecting two nodes that defines data flow and execution order
Trigger: Start node that determines when the flow executes (schedule, webhook, manual)
Save: Action that saves the current board state as a “Saved State” (works like a commit in Git)
Saved State: Specific point in the board’s history, with message, date, and hash
Separate Draft: Parallel version of the board for working without affecting the main one (works like a branch in Git)
History: View of all saved states of the board with change comparison

Mini FAQ

Q: How many nodes can a board have? A: There is no defined node limit. You can add as many as you need.

Q: Can I use a flow inside another (subflow)? A: Yes. The Call Component-Flow node lets you execute a subflow, reusing logic already built in other boards.

Q: How do I monitor my boards? A: Go to Execution History in the sidebar. There you can see the execution history with status (success, error, in progress) and data from each step.

Q: Does the Iterator process elements in parallel? A: No. The Iterator processes elements sequentially (one by one), following FIFO order in the execution queue.

Q: Can I clone a board? A: Currently you can simulate it with Export + Import: export the board as JSON and import it as a new one. A dedicated duplicate button is planned.

Next Steps

Connections - Connect your external applications
Executions - Monitor execution history
Webhooks - Configure real-time triggers
Commands - Transform data with expressions
First Steps - Step-by-step tutorial