Condition Function

The Condition function routes rows to different output paths based on conditions you define. It enables branching logic in your workflows, sending data down different paths for different processing.

How It Works

Condition evaluates each row against your conditions:

• Rows matching the condition go to the True output
• Rows not matching go to the False output
• Every row goes to exactly one output

Unlike Filter (which discards non-matching rows), Condition keeps all rows but routes them differently.

Adding a Condition

1. Drag Condition from the Functions section of the Element Panel
2. Connect it to your data source
3. Click the Condition node to configure the condition
4. Connect the True and False outputs to different downstream nodes

Configuration Panel

Condition Builder

The visual condition builder helps create routing logic:

Single Condition

1. Select a Field from the dropdown
2. Choose an Operator
3. Enter the Value

Example:

Status equals "Priority"

Multiple Conditions

Combine conditions with AND/OR logic:

AND (all must match):

Status = "Active"
AND
Amount > 1000

OR (any can match):

Priority = "High"
OR
DueDate < today

Condition Groups

Create complex logic with nested groups:

(Status = "Active" OR Status = "Pending")
AND
(Amount > 1000)
AND
(Region = "East" OR Region = "West")

Operators

All operators from the Filter function work in Condition:

Text: Equals, Contains, Starts with, Ends with, etc. Number: =, ≠, >, >=, <, <=, Between Date: Before, After, Between, Is null Boolean: Is true, Is false

See Filter Function for complete operator details.

Output Connections

After configuration, the Condition node has two outputs:

True (✓) output:

• Green connection point
• Receives rows matching the condition
• Connect to processing for matching rows

False (✗) output:

• Red connection point
• Receives rows not matching the condition
• Connect to processing for non-matching rows

Common Use Cases

Priority Routing

Scenario: High-priority items need different processing

Condition: Priority = "High" OR Amount > 10000

Flow:

[Orders] → [Condition: High Priority?]
              ├── True → [Expedited Processing]
              └── False → [Standard Processing]

Status-Based Handling

Scenario: Different handling for active vs inactive

Condition: Status = "Active"

Flow:

[Customers] → [Condition: Active?]
                 ├── True → [Update Process]
                 └── False → [Archive Process]

Data Quality Routing

Scenario: Route clean vs problematic data

Condition: Email IS NOT NULL AND Phone IS NOT NULL

Flow:

[Contacts] → [Condition: Complete?]
                ├── True → [Main Processing]
                └── False → [Data Quality Review]

Regional Processing

Scenario: Different processing by region

Condition: Region = "US"

Flow:

[Orders] → [Condition: US Order?]
              ├── True → [US Fulfillment]
              └── False → [International Fulfillment]

Threshold Handling

Scenario: Different rules above/below threshold

Condition: Amount >= 5000

Flow:

[Transactions] → [Condition: Above Threshold?]
                    ├── True → [Require Approval]
                    └── False → [Auto-Approve]

Multiple Conditions (Cascading)

For more than two paths, chain Condition nodes:

Three paths:

[Data] → [Condition: Type = "A"?]
            ├── True → [Process A]
            └── False → [Condition: Type = "B"?]
                           ├── True → [Process B]
                           └── False → [Process C (default)]

Multi-tier priority:

[Tasks] → [Condition: Critical?]
             ├── True → [Immediate]
             └── False → [Condition: High Priority?]
                            ├── True → [Priority Queue]
                            └── False → [Condition: Normal?]
                                           ├── True → [Standard Queue]
                                           └── False → [Backlog]

Merging Paths

After different processing, combine results:

Using Append:

[Condition] → True → [Process A] ─┐
                                   ├── [Append] → [Combined Output]
            → False → [Process B] ┘

Both paths must reach the same destination for complete processing.

Condition vs Filter

Aspect	Condition	Filter
Non-matching rows	Sent to False output	Discarded
Outputs	Two (True/False)	One
Purpose	Route data differently	Remove unwanted data
All data preserved	Yes	No

Use Condition when:

• All rows need processing (just different processing)
• You need both matching and non-matching rows
• Building decision trees

Use Filter when:

• You only want matching rows
• Non-matching rows should be excluded
• Simplifying data before further processing

Condition with Parameters

Use trigger parameters in conditions:

HTTP trigger parameter:

Condition: Region = ${requestedRegion}

Schedule trigger parameter:

Condition: ProcessDate >= ${batchStartDate}

Condition with Expressions

For complex conditions, use expressions:

Date calculations:

Condition: ${OrderDate} > DATEADD(TODAY(), -30, "day")

Field comparisons:

Condition: ${ActualAmount} > ${BudgetAmount} * 1.1

Combining Outputs

Both Paths to Same Destination

Sometimes both paths need the same final output:

[Condition] → True → [Transform A] ─┐
                                     ├── [Append] → [Final Output]
            → False → [Transform B] ┘

Selective Outputs

Only one path produces output:

[Condition] → True → [Process] → [Output]
            → False → (no connection - rows discarded)

Note: Unconnected outputs are valid - those rows simply don't continue.

Cross-Path Enrichment

Enrich based on which path:

[Condition: Premium?]
  → True → [Transform: add IsProcessed=true, Level="Premium"]
  → False → [Transform: add IsProcessed=true, Level="Standard"]

[Append both] → [Continue processing]

Best Practices

Use Meaningful Conditions

Clear:

"Is this a high-value customer?"
Amount > 10000 AND TotalOrders >= 5

Unclear:

"Condition 1"
Amount > 10000

Name Your Outputs

Use descriptive node names for what happens on each path:

• True → "Priority Processing" not "True Path"
• False → "Standard Processing" not "False Path"

Handle All Rows

Ensure both outputs connect somewhere:

• Unconnected = rows discarded
• This should be intentional, not accidental

Test Both Paths

When testing:

1. Use data that triggers True path
2. Use data that triggers False path
3. Verify correct routing for edge cases

Troubleshooting

All Rows Going One Way

Possible causes:

1. Condition too restrictive (all False) or too loose (all True)
2. Data doesn't match expectations
3. Wrong field or operator selected

Debugging:

• Preview data before Condition
• Check actual values vs condition values
• Test with known matching/non-matching data

Rows Disappearing

Possible causes:

1. Output not connected
2. Downstream node failing

Solutions:

• Connect both outputs
• Check downstream processing

Wrong Path

Possible causes:

1. Condition logic inverted
2. AND/OR logic incorrect
3. Case sensitivity issues

Solutions:

• Verify condition matches intent
• Check AND vs OR grouping
• Standardize case before condition

Examples

Approval Workflow

Goal: Route based on approval requirements

Condition: Amount > 5000 OR IsException = true

Flow:

[Expenses] → [Condition: Needs Manager Approval?]
                ├── True → [Manager Approval Queue]
                └── False → [Auto-Approve] → [Payments]

Error Handling

Goal: Separate successful vs failed records

Condition: ValidationStatus = "Pass" AND ErrorCount = 0

Flow:

[Validated Data] → [Condition: Valid?]
                      ├── True → [Process] → [Success Log]
                      └── False → [Error Queue] → [Error Log]

Tiered Processing

Goal: Different processing tiers

Flow:

[Customers] → [Condition: Platinum?]
                 ├── True → [Platinum Service] → [Append] → [Output]
                 └── False → [Condition: Gold?]
                                ├── True → [Gold Service] → [Append] ↗
                                └── False → [Standard Service] → [Append] ↗

Data Routing

Goal: Route to different destinations

Condition: TargetSystem = "SystemA"

Flow:

[Data] → [Condition: To System A?]
            ├── True → [Format for A] → [Write to System A]
            └── False → [Format for B] → [Write to System B]

Next Steps

• Filter Function - Filter instead of routing
• Transform Function - Calculate values for conditions
• Building Flows - Complete workflow guide