RabbinatixDocs
Sign inGet started

Documentation

The logic editor

Logic is what happens inside a system: the steps an API, a button or a scheduled job goes through, drawn as boxes and arrows. This page walks through every part of the editor, how to give your logic its inputs, and every node you can use.

What logic is

A logic belongs to one system (or, as a library function, to none). It starts at one starting point, runs steps one after another along the arrows, and ends by answering or returning. Because it is a model, not code, it can be tested in the editor, read as text steps and turned into TypeScript, Python, C#, Java, Go, Kotlin, Swift, Dart, PHP, Ruby, Rust code. Each kind of logic has its own starting point:

On Requestio.onRequest

The starting point of an API. This logic begins when another system sends a request here. The outputs are the parts of that request: values from the web address, options, extra details and the main information (body).

Example: The web app sends POST /api/v2/login with { "email": "alex@acme.dev", "password": "…" }: that record comes out of Body.

On Eventio.onEvent

The starting point. This logic begins when the person does something in the app, such as pressing a button or submitting a form. Each output is one piece of information they entered.

Example: When someone submits the login form, their email and password come out of this step, ready to be checked.

Function Entryio.functionEntry

The starting point of a reusable piece of logic (a function). The outputs are the values it was given by the step that used it.

Example: A "Price with tax" function starts here with Price = 100 and Tax rate = 0.2 as outputs.

Scheduled Triggerio.trigger

The starting point for work that runs by itself on a schedule, or when a message arrives in a queue, rather than because a person clicked something.

Example: Every night at 2:00, send the daily sales report (schedule "0 2 * * *").

Which kind to choose

When you create logic, you pick its kind in New logic. The kind decides how the logic starts. Ask what starts it: another app calling an API (Endpoint logic), a person doing something in an app (Event / UI action), or other logic that needs the same steps (Function).

Endpoint logic

What a system does when another system calls one of its APIs. It starts from the request and ends by sending the response.

Use it when

  • The system provides an API (a provider endpoint) and you want to describe what happens behind it.
  • Other apps call it over the network, and the contracts they rely on should be checked against it.

Examples

  • POST /api/v2/login: check the password, then return a token
  • GET /api/v1/orders/{id}: load the order, or answer 404

Each API has one endpoint logic. Nothing calls it over the network? Use Event / UI action or Function.

Event / UI action

What an app does when a person does something in it, such as pressing a button or submitting a form. Its inputs are what the person entered.

Use it when

  • The logic runs in a website or mobile app (a consumer) because of something the user did.
  • It usually calls other systems' APIs, then shows the result to the user.

Examples

  • Submit login form: send the email and password to Auth Service
  • Add to cart: call the cart API, then update the badge

Started by an API call? Use Endpoint logic. Called by other logic? Use Function.

Function

A reusable piece of logic: it takes inputs, returns outputs, and runs inside the logic that calls it (a Call Function step).

Use it when

  • The same steps are needed in more than one place: write them once, call them everywhere.
  • A calculation or check that needs no API or user action of its own, such as a price, a validation or a format.
  • Shared by every system: give it no system, or mark it Library.

Examples

  • Price with tax: price and tax rate in, total out
  • Validate address: an address in, a list of problems out

It is what an API or a user action does as a whole? Use Endpoint logic or Event / UI action, and call this Function from it.

The kinds work together: a login button's Event / UI action calls Auth Service's login API, whose Endpoint logic checks the password with a Function it shares with the sign-up API.

Your first logic

  1. New logic on the Logic page (or a system's Logic tab). Pick the kind: Endpoint logic for an API, Event / UI action for something a person does, Function for logic other logic calls (see Which kind to choose). Name it, and list What it takes and What it gives back (you can change both later). Prefer typing? Choose Write as text and write it in FPC: the header says the system and the kind, for example SYSTEM AuthService and ON CALL.
  2. The editor opens with a start step, a Return step, and a Next steps list in the corner of the canvas: set what it takes, add a step, try it with Test, save. Click a step in the list to go where it's done; it goes away once all are done, or when you close it.
  3. Not sure where things are? Take the 1-minute tour from Next steps, from the toolbar's … menu, or from ? in the toolbar, which also opens this guide and the keyboard shortcuts.

The editor at a glance

Five areas. Click one to read about it.

Toolbar

Across the top. On narrow screens the less used buttons move into the More menu; on a phone the bar keeps the name, Undo and Redo, Help, Save and More, and shows the key, the kind, the version and Discuss on a wider screen (on a phone the version is an item of More that opens History).

Back
Returns to the system the logic belongs to, or to the Logic list.
Name, key and version
The logic's name, its key (for example LOGIC-AUTH-LOGIN-001) and its version. Click the name for Logic settings (name, description and more). "v1.2" means this revision is that named version; "v1.2+" means it has changed since. Click the version to open History.
Written by an assistant
Shows when the saved revision is a change your AI assistant drafted and someone accepted. Point at it to see which assistant drafted it, who accepted it and who approved it. It goes away once someone edits the logic by hand. The Logic list can show only these: Written by an assistant.
Undo / Redo
Steps back and forward through your edits since the page opened. Ctrl+Z · Ctrl+Shift+Z
Discuss
Lists your chat rooms (the logic's system channel first) with a search; pick one to open it with a mention of this logic in the message box. "New chat room…" creates a channel there and opens it.
Steps / Flowchart
The switch next to the name: Steps is the canvas you edit, Flowchart shows the same logic as a flowchart (see Flowchart view below). Flowchart is off while you compare with an earlier revision or edit as text: those show on the canvas.
Code
Opens or closes the Code panel on the right. Its tabs, Code, Text and Exported, are in its header; it opens on the last one you used. Ctrl+Shift+C
Test
Opens or closes the Test tab in the bottom panel.
More (…)
History, Where it is used, Copy link (a link to give a teammate), Present (full screen, canvas only, nothing can be edited; a test you ran keeps its playback controls; going to another page ends it), Use other logic… (opens Nodes on Other logic), Duplicate logic, Publish to store (function logic only), Ask your assistant, Is my code in step?, Save as version, this guide, the keyboard shortcuts (or press ?), the 1-minute tour, and Delete. The page's own help is the ? next to its title at the top.
Save
Saves your current changes as a new revision. Until you save, your edits are only in this browser: they are kept through a reload or a crash, and opening the logic again asks to restore them (Restore changes, or Discard them). Ctrl+S

Viewing another environment, such as Production (picked in the header), the editor shows the logic at the revision deployed there, read-only. A note under the toolbar names it ("Viewing Production: rev 4 from Orders API 1.2.0, read-only."), with a button to switch back to Development. Logic not in any release running there says "Not deployed in Production"; a release made before releases recorded their logic says "Not recorded for this release"; reusable logic isn't released on its own. Save, Undo and Redo, Duplicate, Save as version, Delete and Ask your assistant… are hidden, and steps can't be added, changed, moved or deleted, with the mouse or the keyboard: Ctrl+S, Delete and the other shortcuts change nothing. Test, the code and the history still work.

When a pull request changes the code that implements this logic but leaves the logic as it was, an amber note under the toolbar says "The code changed but this logic didn’t: check it still says what the code does." It comes from the change impact check your pipeline runs (see Code impact). See the change opens what that pull request affects. Saving the logic again clears the note; if nothing needs to change, Still correct clears it without a new revision.

Canvas

Where you build. Scroll or pinch to zoom, drag empty space to look around.

Steps (nodes)
Each box is one step. Drag a node from the Nodes tab onto the canvas, or right-click empty space and choose "Add a step here…".
Put a step on an arrow
Hover an arrow (or click it) and press the + in its middle: pick a step and it goes between the two ends, already connected. The steps after it move right to make room. A pasted step goes where it covers no other step.
Start and Return steps
The start step's outputs are the logic's inputs and Return's inputs are its return values: + Add input and + Add return value under them add one, and double-clicking a name renames it.
Arrows (next-step connections)
White arrow connection points decide the next step: a step runs when the arrow coming into it fires. Steps without arrow connection points (calculation steps, such as Add or Equals) work out their result whenever a connected step needs it.
Values (data connections)
Coloured round connection points carry values. Drag from an output to an input of the same type. Drop a connection on empty space to get a list of the nodes that can take it.
Unconnected inputs
An input with no connection uses the value typed in Details → Unconnected inputs.
Select and move
Click to select, Shift+drag to select several, drag to move. Alt+click a connection point breaks its links.
Right-click empty space
Add a step here, Paste, Add sticky note here, Arrange automatically (the next-step path along one straight line, calculations beside the steps they feed; it keeps a zoom where the connection points can be hit, starting at the start step when the whole logic doesn't fit), Snap to grid, Fit to screen, and the logic's settings: Logic settings, Inputs & return values, Links & usage.
Right-click a node
What does this step do?, Details, Connect to…, Key step, Duplicate, Copy, Turn into a function, and Delete. The start step also has Edit inputs…, and a Return step Edit return values….
Sticky notes
A short note on the canvas that only you see (Only me) or everyone in the project sees (Project): pick one under the text before saving. Add one with the sticky note button under the zoom buttons or Add sticky note here; it is saved at once and never makes the logic unsaved, even while the logic is locked. The fold button turns it into an icon for you alone. Only its author changes it. Not shown in the flowchart view or while comparing revisions.
Turn into a function
Moves the selected steps into a new reusable function logic and puts one Call Function step in their place.

Flowchart view

The same logic drawn as a flowchart, easier to read for people who don't build it. Press Flowchart in the toolbar to switch; press it again for the canvas. Nothing about the logic changes.

Steps
Each step that runs is a card, from top to bottom in the order the steps run. The main way runs straight down; other ways branch off to its sides, and an arrow that would cross a step goes round it. The card shows the step's name, what kind of step it is and an icon in the colour of its group. The start and the end are rounded.
Decisions
A Branch, a Switch and the check of a loop are diamonds. Their arrows say where each answer goes: Yes and No, the cases and Otherwise, Each time and Done. Yes is green and No is red.
Loops
The steps inside a loop run under its diamond, and a dashed arrow goes back up to it for the next time round.
Side by side and Try
Parallel splits at a bar and its branches join at a second bar before the logic carries on. Try / Catch and Retry are dashed boxes with an arrow for each case: Try, If it fails, Always.
Values
Values and Set variable steps are not drawn. The step that uses a value lists it under its name, and a step followed by Set variable says "Then sets …".
Not connected
Steps the start never reaches sit in a dashed frame beside the chart.
Testing
With the Test tab open, a run shows on the flowchart: the steps that ran carry their step numbers (×3 inside a loop), the current step glows, a step that failed turns red, and the arrows taken are lit. The rest fades. To see the value on each connection, switch to the canvas.
Changing a step
Click a step to open it in Details and change its settings there. Adding a step from the Nodes tab goes back to the canvas, where the new step is placed.

Side panel tabs

The tab rail on the left of the canvas. Click a tab to open it, click it again to collapse the panel; drag the panel's edge to resize it. On a phone the panel starts collapsed, so the canvas has the screen. People who can only view logic see Details and Variables, not Nodes.

Nodes

What you can add. The switch at the top picks Steps or Other logic. Steps lists every step you can add, in groups: the contracts this system calls, its resources (databases, queues, external services), then flow control, data, operators, text, objects, lists, validation and utilities. Search at the top (press / to jump there), click or press Enter to add, or drag onto the canvas. The ? on each row opens that node's guide, the same guide you find in the Node reference below.

Nodes → Other logic

Function logic you can reuse here (also … → Use other logic…): this system's functions and the library functions every system shares (marked ★). Each one becomes a Call Function step, and its inputs and outputs become connection points.

Details

Settings of what you selected. With nothing selected: this logic at a glance, with its inputs and return values ready to edit, and its variables and problems. For a node: its label, Key step, its own settings (for example the API to call or the status to answer; for the start step the logic's inputs, for a Return step its return values), typed values for unconnected inputs, the values it had in the last test run, tickets and implementation links. For an arrow or a value connection: where it goes and the value it carried in the last run. Types read in everyday words (Text, Number, Whole number, Yes / No, Date, List of texts): type one of those, or the written form such as string[] or { a: string }. The badge counts the selection.

Variables

Values kept while the logic runs, each with a name, a type and a default. Read them with Get Variable and change them with Set Variable. Useful for counters and totals inside loops. The badge counts the variables.

Inputs and return values

Inputs are what a logic is given when it starts: each one is an output connection point on the start step (On Event, Function Entry or Trigger) and a field in the Test tab. Return values are what it hands back: each one is an input connection point on every Return step. Each has a name, a type, and a lock that masks secret values (such as passwords) in test runs. In a narrow Details panel (on a phone) each type sits under its name. You can set them:

  • When you create the logic: the New logic dialog asks for What it takes and What it gives back. Names like password or token get the lock by themselves.
  • On the canvas:+ Add input under the start step and + Add return value under Return. Double-click a name on either step to rename it.
  • In Details: select the start step or a Return step; with nothing selected, Details lists both. Right-click an empty part of the canvas and choose Details to get there from anywhere.
  • From a right-click: the start step's Edit inputs…, a Return step's Edit return values…, or Inputs & return values… on an empty part of the canvas.

The right-click menu of an empty part of the canvas also has Logic settings… (name, description, event name or Library switch; clicking the name in the toolbar opens it too) and Links & usage… (commits, code changes or files that implement the logic, and the flows that run through it).

How to change the inputs, for example to a username and a password

The Test tab shows

{
  "input": "string"
}

What you want

{
  "username": "string",
  "password": "string"
}

The Test tab only has a field for each input the logic declares, so typing other names into its JSON does nothing. Change the inputs on the start step (the first box on the canvas, for example On Event):

  1. Double-click input on the start step. Its name opens in Details: type username and press Enter. Its connections move along.
  2. Press + Add input under the start step, type password and press Enter.
  3. Keep the type string for both (or use another type from the table below). Click the eye next to password to turn it into a lock: its value is masked in test runs.
  4. Connect the new username and password connection points into the next steps.
  5. Open Test and pick Custom input: its fields already follow the inputs. Type your test values and press Run.
  6. Save (Ctrl+S).

Return values work the same way: + Add return value under a Return step, or double-click a name on it. Making new logic? Add username and password under What it takes in the New logic dialog instead.

API logic (logic that implements an endpoint) starts at On Request and ends at Return Response. Its inputs are the request (body, path, query and headers) and its answers are the endpoint's responses, so you change them in the endpoint's declaration and the connection points follow. Select On Request or Return Response (or right-click it and choose Inputs… or Responses…) to see them. The Test tab shows the request under body.

Types you can type for an input or return value

TypeMeans
stringText
string(email)An email address (also date, date-time, uuid, uri, password)
integer · numberA whole number · any number
booleanYes / No
string[]A list of texts
enum(admin, member)One of the listed values
{ name: string, age?: integer }A record with fields (? marks an optional field)

Bottom panel tabs

Below the canvas. Click a tab to open the panel, click it again (or ×) to close it, and drag its top edge to resize it. When the canvas is narrow (both side panels open), the tabs wrap onto a second row; on a phone they stay in one row that you swipe sideways. Problems, Test and History are always there; Where used shows as a tab while it is open. The canvas keeps room for the Test tab: when both side panels are open and it would get too narrow, the panel opened before folds away (open it again from its tabs).

Problems

Everything that stops the logic from running (errors, in red) or looks wrong (warnings, in amber): a required input without a value, a step nothing starts, a check or calculation whose answer nothing uses (it never runs, so it is greyed out after a run: wire its answer into a Branch, or into an AND a Branch reads), a type that doesn't match. Each says what is wrong in words, naming the step by its title; hover one to see its code. Click a problem to jump to its node. An arrow that points at a connection point that is gone (the API or function changed) isn't drawn, so its problem has Remove this arrow. While there are errors, no code is generated.

Test

Run the logic right here (Test in the toolbar opens it too). On the left, pick one of its Examples, a test case of a flow that reaches this logic (listed under From flows), or Custom input, then press Run: the run shows at its end, and the canvas (or the flowchart) lights up the path it took, with the number of times it went along each next-step connection (×3 inside a loop), and the value on every connection. Play replays it step by step; the step buttons and ← → move one step. Custom input has a field per input (Form or JSON; they follow the logic's inputs as you change them), Start from copies an example's inputs, and Reset goes back. Run all runs every example and says how many pass. Each example shows Passes, Fails or No output set. A flow's test case fills in what this logic gets in that case (the case's input when the flow starts here, else what the flow's run hands it on the way) and checks nothing here; if the flow stops before it gets here, it says so. Manage… adds and edits them: the inputs and the output they must return (fields left out aren't checked); Save the logic to keep them. Every example runs again after each edit, and one that returns something else is listed in Problems. Contract calls are answered by the other system's logic, by test data or by generated data. A call whose request doesn't match the other system's contract is listed under the result, as a flow run would fail on it; click it to go to that step. In the list of steps, a call that answered with an error shows its status in red, and Error at, above the list, jumps to where the error starts (a call that failed because of one inside it points at the inner one). A flow's Test panel works the same way over its test cases.

The fields come from the logic's inputs: see how to change the inputs.

History

Every saved revision. Compare any revision with your current changes (added, removed and changed steps are coloured on the canvas), restore one (it asks first, saying how many steps replace how many; the restored revision is saved as a new one, so the logic as it was stays in History), or save a revision as a named version. A revision that an assistant wrote says Written by an assistant. When you compare an older revision, Copy changes for your assistant copies the steps that changed since, by key, so the assistant that wrote your code for that revision updates only those steps (see Keeping code in step on the AI assistant docs page). A change your AI assistant drafted opens the same way: on the Drafts page, Open in the logic editor makes it your current changes, compared with the saved revision; adjust it if you like, and Save accepts it as your own revision.

Where used

Opened from … → Where it is used, and shown as a tab while open: the flows, callers, screens, requirements and tickets that use this logic, so you know what a change affects. Event logic also says, under Details, which screens start it.

Code panel

A panel on the right, opened and closed by Code in the toolbar (Ctrl+Shift+C) or the arrow in its header. Its tabs sit in its header: Code, Text and Exported (saved versions of the logic are under History, at the bottom); it opens on the last one you used. The Code tab shows the code generated from your logic, updated as you edit; while the logic has errors, it lists them instead. Drag its left edge to resize it.

Language
Pick the language to generate: TypeScript, Python, C#, Java, Go, Kotlin, Swift, Dart, PHP, Ruby, Rust.
File tabs
One tab per generated file: the handler, its types, the runtime and the dependencies it needs.
Linked to the canvas
Hover a block of code to outline the nodes it came from; select a node to find its code.
Options (…)
FDD comments (each block names its node key), Format (TypeScript only) and One file (everything in a single file).
Download file / Download all
One file, or the whole package as a zip.
AI prompts… (in …)
In the editor's … menu. Copies a prompt for your AI assistant, connected to Rabbinatix: write this logic’s code, bring your code in step with it, change it, suggest improvements, or explain it. Not connected yet: it opens the connect dialog.
Is my code in step? (in …)
In the editor's … menu. Paste your copy of the code (or just its header) to see if it still matches this version.
Verify against test cases
Runs the generated code against the recorded test cases and shows any difference from the logic.
Text tab
The logic as text steps (the Flow Pseudocode format, FPC), from the same model as the generated code, and you can type in it. Its … menu copies them or downloads a .fpc file, for example to paste into an AI assistant. A dot on the tab shows an edit is under way. How to write text steps opens the guide to the syntax in a new tab. The first change starts an edit: problems show at their line as you type, the canvas shows the result (and takes no edits meanwhile), Apply puts it into your current changes (Undo takes it back, Save keeps it) and Cancel drops it; an edit that adds no step reads Ready to apply. Deleting the last RETURN line removes the Return step, and the text then has no RETURN line, as the canvas has no Return step (logic that reaches its end without one returns nothing more). Closing the panel keeps what you typed. Steps you keep keep their keys, so code marked with them stays in step. A name you give a call’s result (SET payment ← CALL …) stays its name in the text; the step is still titled by the call it makes. The header must stay this logic’s: its key, its system and its kind (ON CALL, ON REQUEST or ON EVENT).
Exported tab
What was exported and when (code and text steps), comparing two exports, and checking a copy.

Keyboard shortcuts

On a Mac, use ⌘ for Ctrl. Shortcuts are off while you type in a field, except Ctrl+S, which saves what you typed.

Ctrl+SSave
Ctrl+ZUndo
Ctrl+Shift+Z or Ctrl+YRedo
Ctrl+C / Ctrl+VCopy / paste steps
Ctrl+DDuplicate the selection
Delete or BackspaceDelete the selected arrow or steps
Ctrl+Shift+CShow or hide the Code panel
/Search the Nodes tab
?Show these shortcuts
FFit to screen
+ / −Zoom in / out
Space, ← →Quick test: play, step back, step forward
EscapeClear the selection or close what is open
In the Nodes tab: ? or F1The guide of the highlighted node

Values, dates and times

What kind of value is it?

Type Of tells you what kind of value arrived. Connect its Type into a Switch with cases such as string, integer and array to handle each kind differently, or into a Log to show it.

TypeMeans
stringText, such as "Alex" or "42"
integerA whole number, such as 42
numberA number with decimals, such as 4.5
booleanYes or no (true or false)
objectA record with fields, such as { "name": "Alex" }
arrayA list, such as [1, 2, 3]
nullNothing: the value is missing or empty

A whole number is integer; Validate Type with number accepts both.

Dates and times

A date is text in the ISO 8601 form, always in UTC: 2026-10-04T09:30:00.000Z. That is what Now gives and what every date node gives back. Date nodes also read 2026-10-04 (midnight UTC), times with an offset such as 2026-10-04T11:30:00+02:00, and numbers of milliseconds since 1 January 1970. Anything else is not a date: To Date answers Valid = no, and the other date nodes stop with INVALID_DATE (catch it with Try).

Add Time and Time Between take a unit: milliseconds, seconds, minutes, hours, days, weeks, months or years (one or many, in any case). Adding a month keeps the day when it can: 31 January plus 1 month is 28 February (29 in a leap year). Time Between counts whole units, so 23 hours is 0 days.

Format Date writes a date with a pattern such as dd/MM/yyyy HH:mm. Its letters:

LettersMeansExample
yyyy · yyYear2026 · 26
MMMM · MMM · MM · MMonthOctober · Oct · 10 · 10
dd · dDay of the month04 · 4
EEEE · EEEWeekdaySunday · Sun
HH · HHour, 0–2309 · 9
hh · h · aHour, 1–12, and AM / PM09 · 9 · AM
mm · mMinute05 · 5
ss · s · SSSSecond and millisecond07 · 7 · 250
'text'Words kept as they are (two quotes for a quote)'at' → at

Any other character is written as is. Put words between quotes: in at the a would become AM or PM.

Custom code

When no node does what you need, add Custom Code: a small function in plain JavaScript that takes inputs and gives back one result. In Details, give it a name, list its inputs (one name: type per line; Types next to the field lists every type you can use), choose the result type and write the code. input holds the inputs; return the result:

// name: initials · inputs: name: string · result: string
return input.name.split(' ').map((w) => w[0]).join('').toUpperCase();

In the editor

Test runs and flow runs run your code in a sandbox: it can't see the page, your sign-in or the network, and each call has 200 ms. Treat it as a pure function: the same inputs should always give the same result. If it throws, takes too long or returns something other than the result type, the logic stops with CUSTOM_CODE_ERROR (catch it with Try).

In exported code

The generated code doesn't contain your JavaScript. It calls deps.code.<name>(input), and the CustomCode interface in the deps file lists every function with its types. Pass in your own implementation next to the database and API clients, in TypeScript, Python or C#, using any library you like (bcrypt, a JWT library, your company's SDK). The editor version can be a simple stand-in, for example a fake hash. Verify against test cases replays the results the editor recorded, so it checks the logic around your function, not the function itself.

One name is one function: two Custom Code nodes with the same name must have the same inputs, result and code.

Node reference

All 140 nodes of the Nodes tab. Open one for its example, what it needs, what it gives back and how to connect it. This is the same guide as the on each row of the Nodes tab. Contract calls, database and queue steps appear in the Nodes tab under the names of your own APIs and resources.

Flow control13

Branchflow.branchA yes/no decision. Checks one condition and takes the True path or the False path. Only one of the two runs.
Sequenceflow.sequenceRuns several paths one after another, in order: everything on Then 0 first, then everything on Then 1, and so on.
Switchflow.switchA multiple-choice decision. Looks at one value and takes the path whose label matches it, or Default if none do. Only one path runs.
For Eachflow.forEachRepeats the connected steps once for every item in a list, in order. Inside the loop, Element is the current item and Index is its position.
For Loopflow.loopRepeats the connected steps a fixed number of times, counting from First to Last. Index tells the steps which round it is.
Whileflow.whileKeeps repeating the connected steps as long as a condition stays yes. The condition is checked before every round.
Breakflow.breakStops the loop it is inside straight away. The rest of the current round is skipped, no further rounds run, and the loop's Completed path runs next.
Parallelflow.parallelStarts several paths at the same time, then continues with Completed when all of them are done.
Try / Catchflow.tryA safety net. Runs the steps on Try; if one of them stops with an error, the Catch path runs instead of the whole logic failing. Finally always runs at the end.
Retryflow.retryTries something again if it fails, waiting a little longer before each new try, up to a set number of tries. Then continues on Succeeded or Failed.
Waitflow.waitPauses for a fixed amount of time, set in Details, before continuing.
Delayflow.delayPauses for an amount of time given by a connected value before continuing. Like Wait, but the length can change from run to run.
Throw Errorflow.throwStops with an error on purpose. The nearest Try / Catch or Retry around it handles the error; if there is none, the whole run fails with this error.

Input / output2

Return Responseio.returnResponseSends the answer back to whoever made the request and ends this logic. The status number tells the caller how it went, and Body carries the information.
Returnio.returnEnds this logic and hands the results back to where it started: the screen the person is looking at, or the step that called this function.

Data16

Valuedata.literalA fixed value you type in yourself: a text, a number, yes/no, a date, a choice from a list, nothing, or a whole record in JSON.
Make Objectdata.makeObjectPuts several separate values together into one record with named fields. Each field you list in Details becomes an input.
Make Arraydata.makeArrayPuts several separate values together into one list, in order. Set how many items in Details; each gets its own input.
Dictionarydata.dictionaryA fixed lookup table typed in Details: each name points to a value. Read one entry with Get Property.
Get Variabledata.getVarReads the value stored in a variable. A variable is a named note this logic keeps while it runs: Set Variable writes it, Get Variable reads it.
Set Variabledata.setVarStores a value in a variable, replacing what was there, so later steps can read it with Get Variable.
Default Valuedata.defaultUses the value if there is one, and a backup value when it is empty (nothing).
Selectdata.selectPicks one of two values depending on a yes/no condition. The path does not split: the same steps run either way, just with a different value.
Parse JSONdata.parseJsonTurns text written in JSON format into structured data, so other steps can read it field by field.
Nowdata.nowThe current date and time, in UTC, as date text such as "2026-10-04T09:30:00.000Z".
Random Numberdata.randomA random whole number between Min and Max, both included.
UUIDdata.uuidCreates a new unique ID (a UUID), a long code that will never clash with another one. Useful as a reference number for new records.
To Stringconv.toStringTurns any value into text.
To Numberconv.toNumberTurns a value into a number, if it can be read as one. Valid tells you whether it worked.
To Booleanconv.toBooleanTurns a value into yes or no.
Type Ofval.typeOfTells what kind of value something is: string (text), integer (whole number), number (with decimals), boolean (yes/no), object (record), array (list) or null (nothing).

Operators15

Equalsop.equalsChecks whether A and B are the same. Gives yes or no.
Not Equalsop.notEqualsChecks whether A and B are different. The opposite of Equals.
Greater Thanop.gtChecks whether A is bigger than B.
Less Thanop.ltChecks whether A is smaller than B.
Greater or Equalop.gteChecks whether A is bigger than or equal to B.
Less or Equalop.lteChecks whether A is smaller than or equal to B.
ANDop.andYes only when both A and B are yes.
ORop.orYes when at least one of A or B is yes.
Addop.addAdds A and B together.
Subtractop.subtractTakes B away from A.
Multiplyop.multiplyMultiplies A by B.
Divideop.divideDivides A by B.
Moduloop.moduloThe remainder after dividing A by B as many whole times as possible.
Compareop.compareCompares A and B and tells their order: -1 if A comes first (is smaller), 0 if they are equal, 1 if A comes after (is bigger). Mainly used inside a function that decides a sort order.
NOTop.notFlips yes to no and no to yes.

Math9

Roundmath.roundRounds a number to a number of decimals. Halves round up.
Round Downmath.floorRounds a number down to a whole number.
Round Upmath.ceilRounds a number up to a whole number.
Absolutemath.absRemoves the minus sign from a number.
Minimummath.minGives the smaller of two numbers.
Maximummath.maxGives the larger of two numbers.
Powermath.powerMultiplies a number by itself a number of times (raises it to a power).
Keep in Rangemath.clampKeeps a number between a lowest and a highest value: below Min becomes Min, above Max becomes Max.
Square Rootmath.sqrtThe square root of a number: the number that, multiplied by itself, gives this one.

String24

Containsstr.containsChecks whether a piece of text appears anywhere inside another text.
Starts Withstr.startsWithChecks whether a text starts with a given beginning.
Ends Withstr.endsWithChecks whether a text ends with a given ending.
Trimstr.trimRemoves spaces, tabs and line breaks from the start and the end of a text. Spaces in the middle stay.
To Lower Casestr.lowerMakes all letters small (lower case).
To Upper Casestr.upperMakes all letters capitals (upper case).
String Lengthstr.lengthCounts how many characters are in a text, spaces included.
Concatstr.concatJoins two texts together, A first and then B, with nothing in between.
Replacestr.replaceSwaps every occurrence of one piece of text for another.
Splitstr.splitCuts a text into a list of pieces at every separator.
Joinstr.joinGlues the items of a list into one text, with a separator between them. The opposite of Split.
Regex Matchstr.regexMatchChecks whether a text follows a pattern (a regular expression), and pulls out the parts of the first match that are inside ( ) in the pattern.
Formatstr.formatFills in the blanks of a sentence. Write the sentence in Details with {name} where a value goes; each {name} becomes an input.
Substringstr.substringTakes part of a text: the characters from one position up to, but not including, another. Negative positions count from the end.
Find Textstr.indexOfFinds where a piece of text first appears. The first position is 0; -1 means it is not there.
Pad Startstr.padStartAdds characters at the start until the text is long enough.
Pad Endstr.padEndAdds characters at the end until the text is long enough.
Base64 Encodestr.base64EncodeTurns text into Base64: a form using only letters, digits, + and /, safe to send where special characters are not allowed (for example in a sign-in header).
Base64 Decodestr.base64DecodeTurns Base64 back into the original text.
Format Numberstr.formatNumberWrites a number as text for people to read, with a fixed number of decimals and a separator between thousands.
Hashstr.hashMakes a fingerprint of a text: a code that is always the same for the same text, but that the text cannot be read back from.
HMAC Signaturestr.hmacSigns a text with a secret key. Only someone with the same key can make the same signature, so it proves who sent the text and that nobody changed it.
URL Encodestr.urlEncodeMakes text safe to put in a web address, for example as a search option. Spaces and symbols become %-codes.
URL Decodestr.urlDecodeTurns %-codes from a web address back into normal text. The opposite of URL Encode.

Object9

Get Propertyobj.getReads one field from a record. The field is set in Details, and can be inside another field.
Break Objectobj.breakOpens a record and gives each of its fields as a separate output. Like several Get Property steps in one.
Set Propertyobj.setMakes a copy of a record with one field changed, or added if it was not there.
Remove Propertyobj.removeMakes a copy of a record without one field.
Mergeobj.mergeCombines two records into one. When both have the same field, the value from B wins.
Transformobj.transformBuilds a new record by copying fields from another record, possibly renaming them and taking them from deeper inside. Lines in Details say which field goes where.
Keysobj.keysLists the field names of a record.
Valuesobj.valuesLists the values of all fields of a record, in the same order as Keys.
Entriesobj.entriesTurns a record into a list with one { key, value } item per field. Handy to go through every field with For Each.

Collection20

Lengthcol.lengthCounts how many items are in a list.
Get Itemcol.getTakes one item from a list by its position. The first item is position 0.
Appendcol.pushMakes a copy of a list with one more item added at the end.
Array Containscol.containsChecks whether a list includes a given item.
Sumcol.sumAdds up all the numbers in a list. With a path in Details, adds up that field of every item instead.
Sortcol.sortPuts a list in order, smallest first (or largest first). With a path in Details, items are ordered by that field.
Mapcol.mapRuns a reusable function on every item of a list and collects what it returns into a new list of the same length.
Filtercol.filterKeeps only the items of a list that pass a check. The check is a reusable function that answers yes (keep) or no (drop).
Find Firstcol.findFinds the first item of a list that passes a check. The check is a reusable function that answers yes or no.
Any Matchcol.someChecks whether at least one item of a list passes a check. The check is a reusable function that answers yes or no.
All Matchcol.everyChecks whether every item of a list passes a check. The check is a reusable function that answers yes or no.
Group Bycol.groupBySorts the items of a list into groups by the value of a field, and gives a record with one list per value.
Averagecol.averageWorks out the average (mean) of the numbers in a list. With a path in Details, the average of that field of every item instead.
Slicecol.sliceTakes part of a list: the items from one position up to, but not including, another. Negative positions count from the end.
First Itemcol.firstGives the first item of a list.
Last Itemcol.lastGives the last item of a list.
Reversecol.reverseTurns a list around, so the last item comes first.
Uniquecol.uniqueRemoves repeated items from a list, keeping the first of each.
Find Itemcol.indexOfFinds where an item is in a list. The first position is 0; -1 means it is not there.
Flattencol.flattenJoins a list of lists into one list.

Date and time8

To Datedate.parseReads a date such as "2026-10-04" or "2026-10-04T09:30:00Z" (or a number of milliseconds since 1970) and writes it in one standard form, in UTC. Valid tells you whether it was a real date.
Format Datedate.formatWrites a date the way people read it, using a pattern of letter codes. Everything is in UTC.
Add Timedate.addMoves a date forward by an amount of time, or back with a negative amount.
Time Betweendate.diffCounts how many whole days (or other units) there are from one date to another. The answer is negative when the second date is earlier.
Date Partsdate.partsSplits a date into separate numbers: year, month, day, hour, minute, second, millisecond and day of the week. All in UTC.
Start of Perioddate.startOfMoves a date back to the start of its hour, day, week, month or year.
End of Perioddate.endOfMoves a date forward to the last moment (…:59.999) of its hour, day, week, month or year.
Make Datedate.makeBuilds a date from its year, month, day and time, in UTC. The opposite of Date Parts.

Validation9

Is Requiredval.isRequiredChecks that a value was filled in. Gives Valid yes or no, and a ready-made message such as "password is required".
Is Emptyval.isEmptyYes if the value is empty: nothing, empty text (or only spaces), an empty list or an empty record.
Is Nullval.isNullYes only if there is no value at all (nothing). Stricter than Is Empty: empty text is still a value.
Validate Emailval.emailChecks that a value looks like an email address: something, then @, then a domain with a dot, without spaces.
Validate Typeval.typeChecks that a value is the expected kind, such as text or a number. Fails with a message such as "age must be integer".
Validate Schemaval.schemaChecks that a record has all the expected fields, each of the right kind. The message names the first problem found.
Validate Rangeval.rangeChecks that a number is between a minimum and a maximum, both included.
Validate Regexval.regexChecks that a text follows a pattern (a regular expression), such as "letters and digits only". Fails with "… has an invalid format".
Validate Passwordval.passwordChecks that a password is strong enough: long enough, and with a digit or a capital letter if required. The message says what is missing.

Boundary (systems)9

Call Contractboundary.callContractSends a request to another system through its agreed API (the contract) and waits for the answer. Each possible answer status has its own arrow.
Query Databaseboundary.queryDatabaseLooks up records in a database, then continues on Found or Not found. In test runs the answer comes from test data.
Database Insertboundary.insertSaves a new record in a database.
Database Updateboundary.updateChanges an existing record in a database.
Database Deleteboundary.deleteRemoves a record from a database.
Publish Eventboundary.publishEventAnnounces that something happened by putting a message on a queue or topic, so other systems that are listening can react. It does not wait for them.
Consume Eventboundary.consumeEventPicks up the next message waiting in a queue.
Call External Serviceboundary.callExternalCalls an outside service that is not one of your own systems, such as payments, email or text messages.
Cacheboundary.cacheA short-term memory: Set stores a value under a name (the key); Get looks it up, so something slow does not have to be fetched again.

Functions2

Call Functionfn.callUses a reusable function defined elsewhere, like following a shared recipe: you give it values, it runs its own steps, and hands its results back here.
Custom Codecode.customYour own small function, written in plain JavaScript: it takes the inputs you list and gives back one Result. In the editor it runs your code safely in a sandbox. In exported code it calls deps.code.<name>(input), so the developers supply the real version, for example with a library.

Utility4

Rerouteutil.rerouteA bend point that only tidies up a long data connection. It does not change the value.
Reroute (exec)util.rerouteExecA bend point that only tidies up a long arrow. It does not change anything.
Logutil.logWrites a note to the run log, handy for seeing what happened during a test.
Templateutil.templateFills a ready-made JSON shape with values from a record. Write the shape in Details with {{name}} where a value goes.