Design your Flow

The Flow App Studio builder is a visual, node-based editor. You arrange nodes on a canvas, connect them with edges, and the Flow Engine executes the resulting graph when a user interacts with your channel.

Projects

A project holds one flow. Every project has two versions:

Publishing promotes Draft → Live. You can continue editing Draft after publishing.

Project settings

Each project has:

• Name — display name shown in the builder
• Category — organise projects by type (e.g. survey, chatbot, USSD)
• Secrets — encrypted values (API tokens, passwords) injected at runtime
• API Calls — reusable external HTTP calls you can invoke from nodes

Flow Nodes

Nodes are the building blocks of a flow. Each node represents one step in the interaction.

Start Node

The entry point. Every flow has exactly one Start Node. When a user initiates a session, the engine begins here.

Normal Node

An intermediate step. A Normal Node displays content to the user and optionally presents response options. The user’s reply routes them to the next node via a connected edge.

Node content supports:

• Plain text
• Variables — {{group.name}} syntax (see Variables below)
• Expressions — <<expression>> syntax for computed values
• Newline character: ^ produces a line break in the output

End Node

Terminates the session. Connect any node’s output to an End Node when a conversation path concludes.

API Call Node

Calls an external HTTP endpoint mid-flow. Responses are stored and available as variables in subsequent nodes. Configure the API call under Project → API Calls first, then reference it in the node.

Go-To Node

Redirects execution to another node without creating a user-visible step. Useful for loops or shared branches.

Node Context Menu

Right-click the canvas to open the context menu:

• + Create Node — adds a Normal Node
• + API Node — adds an API Call Node
• + Go To Node — adds a Go-To Node

Variables

Interpolate dynamic values inside node content using double curly braces:

{{session.id}}         — the unique session ID
{{session.msisdn}}     — the user's phone number (USSD/WhatsApp)
{{session.input}}      — the user's last input
{{secret.MY_TOKEN}}    — a decrypted secret value
{{api.response_key}}   — a field from the last API call response

Expressions use <<...>> for computed values evaluated at runtime:

<<session.step_count + 1>>
<<user.balance * 0.05>>

Access Points (Triggers)

An Access Point (called a Trigger in the API) is the connection between a Flow App Studio provider and your project. Each Access Point has a unique webhook URL and a request/response mapping.

Endpoint URL

The URL you register with your channel provider (USSD gateway, Telegram, WhatsApp, etc.). Flow App Studio generates this URL when you create an Access Point.

Request Mapping

Tell Flow App Studio how to read incoming request fields from your provider. Map your provider’s field names to the platform’s internal names:

Standard fields:

The provider column shows the example default — update it to match your actual provider’s field names.

Pagination

When a node’s response is too long for a single screen (common in USSD), the engine paginates automatically.

Set the characters your provider uses in the Access Point’s pagination settings.

Response Mapping

Configure how Flow App Studio formats its reply back to the provider. Set a response_template and newline character to match what your provider expects.

Providers

A Provider is a channel integration at the organisation level. Providers are reusable across projects.

Supported channel types

See Deploy for step-by-step credential setup per channel.

API Calls

API Calls are reusable outbound HTTP request definitions stored at the project level.

Configure an API Call with:

• HTTP method (GET, POST, PUT, etc.)
• URL (supports variable interpolation)
• Headers
• Body template

Once defined, reference the API Call in a node. The engine executes the request at runtime and makes the response fields available as {{api.field_name}} variables.

Secrets

Secrets are encrypted key/value pairs for sensitive values like API tokens, passwords, and signing keys. They are stored encrypted at rest and decrypted only at runtime.

Access in nodes: {{secret.MY_TOKEN}}