Branch or loop

Hold records until upstream finishes, then release to output streams one at a time

Test entered values in an app or macro and branch on true or false

Run a group of tools only on a signal, to set the order of execution in a workflow

Input of a batch macro: the macro is reconfigured and rerun for each incoming record

Bypass a section of a workflow by a switch, for apps and macros

Rejoin the two paths of an upstream Detour into one stream

Limit the number of records passed per minute to downstream tools

Hold all output until the last input row has arrived, optionally passing every row

Wait until named transform copies have finished before passing rows on

Pause for a set time before passing each row on

Emit one empty row when the input stream has no rows

Do nothing; a placeholder or junction in the workflow layout

Pass rows through unchanged; a placeholder or stream junction

Signal the enclosing Repeat action to stop looping

Wait for parallel branches to finish before continuing

Run a pipeline or workflow repeatedly until a variable or End repeat stops it

Compare a variable or result field with a value to branch the workflow

Entry point of every workflow

Pause the workflow for a set time

Poll a SQL query until its row count meets a condition or a timeout passes

Wait until a file appears, checking at intervals up to a timeout

Throttle the rate at which data passes to downstream processors

Distribute FlowFiles across downstream relationships by a strategy such as weighted round robin

Enforce the expected order of FlowFiles that belong to the same group

Clone each FlowFile into original and enrichment branches, tagged for JoinEnrichment

Combine the data from several connections into a single connection

Cache a release signal so FlowFiles held at the matching Wait processor are released

Route HL7 messages by user-defined HL7 queries, one relationship per query

Route FlowFiles by Expression Language conditions over their attributes

Route a copy of the FlowFile to each relationship whose regular expression matches the content

Hold FlowFiles until a matching release signal from Notify appears in the cache

Apply a transform to each frame of a collection and keep the results as a collection

Apply a transform to each frame of a collection

Choose one frame from a collection of frames

Pick one frame out of a collection of frames

Iterate over a collection and run the inner activities for each item

Run one set of activities when a condition is true and another when it is false

Apply more than one set of transformations to the same stream

Run the set of activities of the case that matches an evaluated expression

Do-until loop: repeat activities until a condition is true or a time-out passes

Continue only once a reference dataset exists or meets criteria, or a time-out passes

Pause the pipeline for a set time

18 platform types (bq.sensor.query, …): wait until a query returns a result

14 platform types (bq.sensor.table, …): wait until a named table exists

Wait until an object matching a name or wildcard exists in a GCS bucket

Wait until any object exists under a prefix in a GCS bucket

Wait until an S3 key or wildcard match exists, optionally checking etag, size or modified time

run a referenced pipeline once per upstream row

run a referenced pipeline N times

run the downstream branches concurrently over one input snapshot

send the same rows to several downstream outputs

no-op node that ordering links attach to

route rows to case outputs by condition, first match wins, plus a default

delay the stage to a rows-per-second target, then pass rows through

sleep a fixed time, then pass rows through

Stop project execution at this point

Pass on whichever of the current table and another table is not empty

Run another module or project once per row of the table

Run another module or project once per column and append the returned columns

Run another module or project once per row, passing another table to it

Run another module or project repeatedly until or while its output is empty

Skip the remaining actions of the table when a condition holds

Skip the remaining actions of the table when the data is unchanged since the last run

Skip the remaining actions of the table when a condition on another table holds

Hold a mutual-exclusion lock on a resource across concurrently running projects

Pause this action chain until another table has finished calculating

Pause for a given number of seconds

Flip a branch between active and inactive, for example to run a branch only on failure

Halt execution when the incoming table meets a condition

Merge one or more active branches back into one

Route the input to one selectable output branch

Open a loop that processes a consecutive chunk of rows per iteration

Open a loop that iterates over the columns of a table

Open a loop that runs a fixed number of times

Route data to the first output when the table has rows, otherwise to the second

Take whichever branch is active, or stack both tables when both carry data

Open a loop with no built-in end condition, closed by a variable-condition loop end

Open a loop that processes one group of rows per iteration

Send data to the top, bottom or both output branches by configuration

Open a loop that steps a numeric variable through an interval

Choose the output branch from a user-written Java expression returning 0 or 1

Extension outside the base install: 3 current nodes: Parallel Chunk End; Parallel Chunk End (multi port); Parallel Chunk Start

Close a loop and stack the tables from every iteration row-wise

Close a loop and join the tables from every iteration column-wise on RowID

Close a recursive loop, feeding its input back to the loop start for the next iteration

Open a recursive loop that receives tables back from the loop end each iteration

Open a loop with one iteration per row, exposing that row's values as flow variables

Close a loop when a condition on a flow variable is met

Close a loop collecting only the flow variables produced, not data

Pause for a duration, until a time of day, or until a file is created, changed or deleted

Open a loop that slides a fixed-size window of rows over the table, one step per iteration

Hold this step until selected other steps have finished

Hold the flow until every input row has arrived, then pass on only the last row

Pass each row on only after a delay

Emit one empty row when the input stream holds no rows

Pass rows through unchanged; used for testing or to split streams

Sample plugin step kept as a developer example; no data function documented

Iterate over the groups as pairs of key and sub-frame

If-then-else: run one of two subprocesses depending on a condition

Combine several objects into one collection

Pause process execution for a fixed or random time

Flatten a collection of collections into one collection

Pass on the first non-null input, merging alternative branches

Run a subprocess a fixed number of times, optionally in parallel

Repeat a subprocess while a condition holds

Run a subprocess for every combination of columns within a size range

Run a subprocess once per selected column

Run a subprocess on successive batches of rows

Run a subprocess once per cluster, on that cluster's rows

Run a subprocess once per object in a collection

Run an inner learner on only a given fraction of the rows

Run a subprocess once per input table

Run a subprocess once per row

Run a subprocess once per label column

Run a subprocess for every combination of given parameter values

Repeat a subprocess until a performance or iteration condition is met

Run a subprocess once per distinct value of a column

Run a subprocess n times and average the resulting performance values

Run a subprocess n times and return the results of the best-performing iteration

Copy an object to several output ports

Reuse the current in-database result on several branches

Slide a window over a series and run an inner subprocess on each window

Pick one object from a collection by index

Switch: run the one subprocess selected by a parameter

Run several subprocesses in parallel

Apply an anonymous function to each item of a list and emit the results, like a for loop

Keep the items of a list that satisfy an anonymous SQL condition, for use by other macros

Emit one SQL fragment or another according to a condition evaluated at render time

Combine the items of a list into one expression with a two-argument anonymous function

Python functions that decide whether a model interval is ready for the scheduler to evaluate

Feed the parallel execution processes with the threads tPartitioner generated

Assemble the outputs of the parallel execution processes for tRecollector

Turn each input row into an iteration, storing its values in global variables

Loop over a list of values through an iterate link

Run a task in an endless loop

Turn the iterations over a list into a flow of rows

Run a task or a Job repeatedly in a loop

Run several subJobs at once and synchronise another subJob with them

Trigger the tasks to run after the Job has executed

Trigger the tasks to run before the Job executes

Output the results of parallel execution that tDepartitioner assembled

Duplicate the incoming flow into identical output flows

Pause the Job for a set time

Watch a directory and trigger the next component when a file event occurs

Listen on a port and trigger a subJob when data arrives

Poll a database and trigger a subJob when a condition on the presence of rows is met

Rerun the previous modifying command with the same input

Rerun the previous command with its input N times

Rerun the previous command once per selected row

Rerun the most recent command, prompting for fresh input

Cancel the replay in progress