Flow

Control how records move through a flow: start it, branch, loop, wait, retry and handle errors.

Need	Plugins
Start a flow on a schedule or from another flow	Timer, Start flow
Branch	Decision router
Loop	For each, Range
Collect records into one	Build array
Reshape a record	Data mapper
Run branches in parallel and combine the answers	Scatter, Gather
Run in the background, one at a time or a few at a time	Fork, Lock, Semaphore
Order steps	Sync call, Wait
Handle errors	Try catch, Retry, Error, Stop execution
Observe	Log, Alarm
Publish a flow as a plugin	Plugin port, Plugin port response

Http listener → Scatter → Http client (prices) → Gather → Http response
                        → Sql query (stock)    →

Data sampler generates test records while you build.

Plugins

Plugin	What it does	Pins
Alarm	Pass-through component that raises a flow alarm (an alarm definition from the repository) when a condition is met: on every request, on a downstream exception, on a slow request, or when the request rate in a time window is too low or too high. Place it in front of the part of the flow you want to monitor.	Input, Output, OnRaise
Build array	Collects single records arriving on Input into one collection record and sends it to Output when the batch they belong to completes (e.g. one file read, one Sql query execution), or, for records without a batch, when the buffer is full or after an idle timeout. Use it to batch records for bulk inserts, bulk API calls or to rebuild a list after a ForEach.	Input, Output
Data mapper	Copies property values from the input record into a new record of another type, field by field, as defined in the mapping editor. Use it to turn one structure into another, for example a database row into an API request or a JSON document into a flow type.	Input, Output
Data sampler	Generates test data: for every message on Input it creates a new record of the output connection's type and fills its properties with (optionally seeded) random values. Use it to exercise a flow without a real data source, for example Timer → Data sampler → the flow under test.	Input, Output
Decision router	Routes each record to one of several branches. A C# script returns a route name for the record; the record is sent to the outgoing connections whose route id equals that name. Use it for if/else and switch-like branching.	Input, Output
Error	Throws a configurable error when a record reaches it. Use it to end a request with a failure (validation failed, not found, ...) that upstream error handling (Try catch, Retry, HTTP listener error response) reacts to.	Input
For each	Splits a list property of the input record into single items and sends each item to Output, sequentially or in parallel. Use it to process the elements of a list one by one (call an API per item, map items, write them to a database).	Input, Output
Fork	Runs the connected branch on its own background task for every input record and returns at once, so the caller does not wait for the downstream processing. Use it to decouple a slow branch from a fast producer (for example answer an HTTP request and process the data in the background) or to process records in parallel with a limit.	Input, Output
Gather	Second half of the scatter-gather pattern: waits for the results of all branches started by a Scatter component and emits them as one combined object. The output type is generated from the components connected to its input.	Input, Output
Lock	Lets only one record at a time pass through to the components behind it. Use it when concurrent requests (for example several HTTP calls, Fork tasks or a parallel For each) must not run a section of the flow at the same time, such as updating a shared file or a counter.	Input, Output
Log	Writes an entry to the flow log for each record that passes, with a fixed message, the chosen severity and the record and its metadata attached, then forwards the record unchanged. Use it to trace what goes through a branch or to log errors from error pins.	Input, Output
Pin to metadata	Stores the record passing through in a named property of the flow metadata and forwards it unchanged. Later components and scripts of the same request can read the value from the metadata without a direct connection, for example to combine the original request with a later response.	Input, Output
Plugin port	The entry point of a flow that is published as a plugin ("flow as plugin"). Other flows then use the published flow like any other component: what they send to its Input pin comes out of Request here, and what this flow sends to Response (or to a Plugin port response component) comes out of the component's Output pin in the calling flow.	Request, Response, Initialize
Plugin port response	Sends the response of a flow that is published as a plugin back to the calling flow, exactly like connecting to the Response pin of the Plugin port. Use it to answer from several places of the flow without drawing long connections back to the Plugin port.	Response, Continue
Range	Loop component: calls Output once for every integer from Start (inclusive) to End (exclusive) with the same input record, then calls Continue once. The current index is available in the metadata property RangeInfo.	Input, Output, Continue
Retry	Calls the components behind Output; when they fail with an exception, the record is put into a retry list and re-sent later, up to MaxRetries times. If it still fails, the record goes to the MaxRetries pin.	Input, Output, MaxRetries
Scatter	First half of the scatter-gather pattern: sends the same input message to every component connected to Output, in parallel, and tags each copy so that a Gather component can later combine the branch results into one message.	Input, Output
Semaphore	Throttles parallelism: at most Slots records at a time may run through the components behind Output; further records wait until a slot is free. Use it in front of resources that must not be called by too many threads at once (APIs with rate limits, databases).	Input, Output
Start flow	Starts another flow of the repository, in the same way as pressing Start for it, and then calls Continue either right after the flow has started or after it has stopped. No data is passed to the started flow and nothing is returned from it.	Input, Continue
Stop execution	Stops the processing of the current request: after a record reaches this component, no further component is called for any record that shares the same metadata instance. The flow itself keeps running.	Input
Sync call	Sequencer inside one flow: sends the record to Output, waits until that branch has completed, then sends the same record to Continue. Use it to run "first this, then that" with the same data. It does not call other flows.	Input, Output, Continue
Timer	Scheduler that periodically calls the components connected to Continue, at a fixed interval aligned to a time of day. Use it as the start of polling, batch and heartbeat flows. It keeps the flow running.	Start, Continue
Try catch	Error handler: runs the components behind Try; if they fail with an error, the record is sent to Catch with the error details in the metadata property Error.	Input, Try, Catch
Unknown plugin	Hidden placeholder. The designer shows it in place of a component whose plugin is no longer installed, so that the flow can still be opened and edited. It cannot be added from the toolbox.	Input, Output
Wait	Delays each record by a fixed number of milliseconds, then passes it on unchanged. Use it for simple pauses between steps or crude rate limiting.	Input, Output