Execution Flow

Overview

Execution Flow defines how a workflow progresses through its nodes—the order of execution, decision points, and control mechanisms that determine which paths are taken during runtime.

🎯 Critical Concept

Understanding execution flow is essential for designing robust workflows that behave predictably and handle various scenarios gracefully.

---

Execution Models

Test Orchestration supports multiple execution models to handle different workflow patterns.

1. Sequential Execution

Nodes execute one after another in a defined order.

Node 1 ──(complete)──→ Node 2 ──(complete)──→ Node 3 ──(complete)──→ End
   ↓                      ↓                      ↓
 Pass                   Pass                   Pass
 5 sec                  10 sec                  8 sec
              Total Time: 23 seconds

When to Use:

• Dependencies between steps

• Data must flow sequentially

• Each step requires output from previous

• Logical sequence is important

Example Workflow:

1. Create User Account
2. Send Verification Email
3. Verify Email Received
4. Login with Credentials

2. Conditional Execution

Different paths execute based on conditions.

          ┌─ Condition Met ─→ Node 2A ─→ Node 4
Node 1 ──┤
          └─ Condition Not Met ─→ Node 2B ─→ Node 4

When to Use:

• Different scenarios based on input

• Environment-specific paths

• Optional steps

• Error recovery paths

Example Workflow:

1. Get User Status
2. If user_type = "admin"
   └─ Run Admin-Only Tests
3. Else
   └─ Run Standard Tests
4. Verify Results

---

Execution Order

Linear Flow

The most common execution pattern—nodes execute one by one.

Definition:

Node A → Node B → Node C → Node D

Configuration:

1. Add nodes to workflow

2. Connect them sequentially

3. Each outputs to next input

Execution Timeline:

|--NodeA--|--NodeB--|--NodeC--|--NodeD--|
0         5         15        25        35 seconds

Alternative Flow

Multiple independent nodes run in optimized sequence.

Definition:

           ├─ Node B
Node A ────┼─ Node C
           └─ Node D
           │
           └─→ Node E

Configuration:

1. Add multiple nodes

2. Set multiple targets from same source

3. Ensure nodes are independent

Execution Timeline:

|--NodeA--|
          |--NodeB--|
          |--NodeC--|
          |--NodeD--|
                 └──NodeE──|

Conditional Flow

Branching based on conditions or data.

Definition:

           ├─ If condition ─→ Node B
Node A ────┤
           └─ Else ──────→ Node C
                 │
                 └────→ Node D

Configuration:

1. Add If-Then or Switch node

2. Define conditions

3. Connect different paths

Execution Timeline:

|--NodeA--|--If/Then--|
                 ├─ Path1: |--NodeB--|--NodeD--|
                 └─ Path2: |--NodeC--|--NodeD--|

---

Branching and Conditionals

If-Then Branching

Execute one of two paths based on a condition.

Node 1: Fetch User
    ↓
If-Then: Is user.role = "admin"?
    ├─ If TRUE  → Node 2A: Run admin tests
    └─ If FALSE → Node 2B: Run user tests
    ↓
Node 3: Cleanup

Condition Syntax:

Use expressions to define conditions:

// Simple comparisons
${NODE_1.status} = "active"
${NODE_1.count} > 10
${PROJECT.ENVIRONMENT} = "staging"

// Complex expressions
${NODE_1.status} = "active" AND ${NODE_1.count} > 5
${NODE_1.email_verified} = true OR ${NODE_1.phone_verified} = true

// Regex matching
${NODE_1.email} matches ".*@company.com$"

// Array operations
${NODE_1.permissions} contains "admin"

Creating If-Then Node:

1. Add If-Then node

2. Click Edit Condition

3. Build expression:

   • Select variable or field

   • Choose operator

   • Enter comparison value

4. Configure true path (Yes branch)

5. Configure false path (No branch)

6. Save

Switch Branching

Route to multiple paths based on a value.

Node 1: Get environment
    ↓
Switch: Which environment?
    ├─ Case "development"  → Node 2A
    ├─ Case "staging"      → Node 2B
    ├─ Case "production"   → Node 2C
    └─ Default             → Node 2D
    ↓
Node 3: Run tests

Creating Switch Node:

1. Add Switch node

2. Click Edit Expression

3. Select variable to switch on

4. Add cases:

   • Click Add Case

   • Enter value to match

   • Select node to execute

5. Configure default case

6. Save

Combining Multiple Conditions

Create complex decision logic:

Node 1: Fetch data
    ↓
If: (user_type = "premium" AND subscription_valid = true) OR trial_active = true
    ├─ TRUE  → Node 2: Full feature tests
    └─ FALSE → Node 3: Limited feature tests
    ↓
Node 4: Verify results

---

Error Handling Flow

Basic Error Handling

Configure what happens when a node fails.

Node 1: Execute test
    ├─ Success → Node 2
    └─ Failure → Error Handler Node
                    ├─ Log error
                    ├─ Send alert
                    └─ Continue/Stop

Error Handler Configuration

For each node, set error behavior:

Option	Behavior	Use Case
Continue	Proceed to next node despite failure	Non-critical tests
Stop	Halt entire workflow	Critical step failure
Retry	Automatically retry the node	Transient errors
Jump To	Skip to specific node	Error recovery
Custom	Run custom error handler	Complex logic

Configuration:

1. Select node

2. Click Execution Settings

3. Find On Failure

4. Choose error behavior

5. Configure options

6. Save

Retry Logic

Automatically retry failed nodes.

Node 1 (Attempt 1) → FAIL
    ↓
Wait 5 seconds
    ↓
Node 1 (Attempt 2) → FAIL
    ↓
Wait 10 seconds (exponential backoff)
    ↓
Node 1 (Attempt 3) → SUCCESS
    ↓
Node 2: Continue

Retry Configuration:

1. Select node prone to failure

2. Click Execution Settings

3. Enable Retry on Failure

4. Set:

   • Max Attempts: 2, 3, or custom

   • Interval: Time between retries (seconds)

   • Exponential Backoff: Double wait each time

   • Retry Only On: Specific error types (optional)

5. Save

Example Configuration

Max Attempts: 3
Interval: 5 seconds
Exponential Backoff: Yes
Retry Only On: Timeout, Connection Error

When to Use

💡 Exponential Backoff: Increases wait time between retries to give systems time to recover.

Try-Catch Pattern

Implement error recovery.

Try Block (Node 1):
    Execute risky operation
    ↓
Success → Continue (Node 3)
    
Catch Block (Node 2):
    Handle error
    Cleanup resources
    Send notification
    ↓
    Continue (Node 3)

Implementation:

1. Add primary node (e.g., API call)

2. Set error behavior to "Jump to error handler"

3. Add error handler node

4. Define error recovery logic

5. Both paths merge to continue workflow

---

Flow Control Nodes

Wait Node

Pause execution for a specified duration.

Syntax:

Wait: 5 seconds
Wait: 30 seconds
Wait: 2 minutes

Uses:

• Let server process data

• Allow email delivery

• Stagger API requests

• Avoid rate limiting

Configuration:

1. Add Wait node

2. Set duration

3. Optional: Set condition to wait until true

4. Save

Conditional Wait:

Wait until: ${NODE_1.status} = "completed"
Max wait: 60 seconds
Poll interval: 5 seconds

Skip Condition

Skip a node based on a condition.

Node 1: Create user
    ↓
Node 2: Send verification email
    Skip if: ${NODE_1.environment} = "test"
    ↓
Node 3: Verify email

Configuration:

1. Select node

2. Click Execution Settings

3. Set Skip If condition

4. Save

When condition is true, node is skipped and execution continues to next node.

Stop/End Node

Terminate workflow execution.

Node 1: Check precondition
    ↓
If condition not met → Stop (workflow ends)

Configuration:

1. Add Stop node

2. Set:

   • Exit Status: Success, Failure, or custom

   • Message: Reason for stopping

3. Optionally set condition to only stop if needed

---

Data Flow Through Execution

Output Chain

Data flows from node to node through the execution chain.

Node 1: Create User
├─ Output: user_id = "123", email = "[email protected]"
    ↓
Node 2: Login
├─ Input: email = ${NODE_1.email}
├─ Output: session_token = "abc-xyz", last_login = "2024-01-28"
    ↓
Node 3: Get Profile
├─ Input: session_token = ${NODE_2.session_token}
├─ Output: profile = {...}

Variable Scope

Variables are accessible based on scope.

Scope	Accessible From	Example
Global	Any node in any workflow	${PROJECT.BASE_URL}
Workflow	Any node in this workflow	${WORKFLOW.SUITE_ID}
Node Output	Downstream nodes only	${NODE_1.user_id}
Local	Only within node	${LOCAL.temp_var}

---

Execution Timeline

Real-Time Execution Monitoring

During workflow execution, monitor:

1. Current Node - Highlighted in real-time

2. Execution Time - Elapsed time for current node

3. Logs - Live logs as execution progresses

4. Status - Pass/Fail/Running for each node

5. Stop Control - Can stop execution anytime

Execution Metrics

After completion, review:

Metric	Meaning
Total Duration	Start to finish time
Node Duration	Time spent in each node
Idle Time	Time spent in Wait nodes
Success Rate	Percentage of passed nodes

Timeline Visualization

Timeline View:
┌──────────────────────────────────────────────────┐
│ Node1 [████████] 5s                              │
│ Node2      [█████████████] 10s                   │
│ Node3A         [████] 4s                        │
│ Node3B         [██████] 6s                      │
│ Node4              [█████] 5s                    │
├──────────────────────────────────────────────────┤
│ Total Time: 26 seconds (vs 30 if sequential)    │
└──────────────────────────────────────────────────┘

---

Advanced Flow Patterns

Loop Pattern

Repeat a sequence until condition is met.

Node 1: Initialize counter
    ↓
Loop Start:
    Node 2: Fetch data
    Node 3: Process data
    Counter++
    ↓
    If counter < max
        → Loop back to Node 2
    Else
        → Continue
    ↓
Node 4: Finalize

Fork-Join Pattern

Sequential execution with conditional merging.

            ┌─→ Task A ─┐
Start ──────┼─→ Task B ─┼──→ Merge → End
            └─→ Task C ─┘

Error Recovery Pattern

Graceful error handling with fallback.

Node 1: Try primary operation
    ├─ Success → Continue
    └─ Failure → Retry
                ├─ Success → Continue
                └─ Failure → Use fallback
                            Node 2: Alternate operation
                            ↓
                            Continue

---

Best Practices for Execution Flow

1. Keep Flows Simple

   • Avoid overly complex branching

   • Use sub-workflows for complex logic

2. Clear Error Handling

   • Define what happens on failure

   • Use meaningful error messages

3. Optimize for Performance

   • Use efficient execution strategies

   • Minimize wait times

4. Document Flow

   • Add comments explaining complex branches

   • Document conditions and decisions

5. Test Thoroughly

   • Test all execution paths

   • Verify error scenarios

6. Monitor Execution

   • Review execution logs

   • Track execution metrics over time

---

Summary

• Sequential flow executes nodes one after another

• Conditional flow branches based on data or expressions

• Error handling defines behavior on failures

• Data flows through node outputs to downstream inputs

• Flow control nodes manage execution pace and logic

---

Related Topics

• Nodes and Steps - Understand node types

• Workflows - How workflows orchestrate execution

• Environments - Configure execution environments

• Data Propagation - Pass data between steps

• Error Handling - Handle failures

• Conditional Execution - Create branching logic

Next: Learn about environment configuration in Environments.