Workflow Templates

Reusable workflow templates to accelerate your development

Workflow Templates are proven structural patterns designed as starting points for building new workflows. They provide the foundational architecture and logic you customize for specific testing needs.

Templates vs Samples

Templates: Reusable structures you customize (like a blueprint) Samples: Complete, ready-to-use workflows (like a finished model)

Use templates to build new workflows from scratch, or samples to get started quickly.

Template Categories

📊 Sequential Pattern Template

Linear execution where each step depends on the previous completing successfully.

Structure:

Step 1
  ↓
Step 2
  ↓
Step 3
  ↓
Step 4
  ↓
Complete

When to Use:

✅ Steps have dependencies
✅ Must execute in specific order
✅ Simple workflows
✅ Straightforward test flows

Template Configuration:

Name: Sequential Workflow Template
Pattern: Sequential
Steps:
  - Step 1: [Configure your first action]
  - Step 2: [Configure your second action]
  - Step 3: [Configure your third action]
  - Step 4: [Configure your fourth action]

Characteristics:
  - Linear progression
  - Each step waits for previous
  - Easy to understand
  - Slower execution
  - No parallel operations

Example Implementation:

Workflow: User Registration

1. Navigate to signup page
2. Fill registration form
3. Submit form
4. Verify email sent
5. Click email confirmation link
6. Validate account created
7. Login with new account

Customization Guide:

Replace placeholder steps with your actions
Configure assertions for validations
Set timeouts appropriate for your application
Add error handling as needed

Configuration Tips:

✓ Add meaningful step names
✓ Include wait times for page loads
✓ Add assertions to verify progress
✓ Include error recovery steps
✓ Document expected results

Related: Sequential Pattern

🔀 Conditional Execution Template

Execute different paths based on conditions or decision logic.

Structure:

Decision: Is condition true?
  ├─ Yes → Execute Path A
  │         └─ Steps A1, A2, A3
  └─ No → Execute Path B
          └─ Steps B1, B2, B3

When to Use:

✅ Different behavior based on conditions
✅ Error handling branches
✅ Feature flags or environment-based logic
✅ Business logic validation

Template Configuration:

Name: Conditional Execution Template
Pattern: Decision-based
Condition Types:
  - If/Then/Else
  - Switch (multiple conditions)
  - Boolean logic
  - Comparison operators

Basic If/Then/Else:
  Condition: [Define your condition]
    If True:
      - Step A1: [Action if true]
      - Step A2: [Validation if true]
    If False:
      - Step B1: [Action if false]
      - Step B2: [Validation if false]

Example Implementation:

Workflow: Order Processing with Conditional Handling

1. Check order total
2. Decision: Is order > $100?
   If Yes:
     a. Apply bulk discount
     b. Process premium shipping
   If No:
     a. Apply standard discount
     b. Process standard shipping
3. Continue to payment

Condition Examples:

# String comparison
Condition: user_type == "premium"

# Numeric comparison
Condition: order_total > 100

# Boolean check
Condition: shipping_required == true

# Multiple conditions
Condition: (user_type == "premium") AND (order_total > 100)

Advanced Conditions:

# Switch statement
Switch: response_status
  Case 200: Validate successful response
  Case 400: Handle bad request
  Case 404: Handle not found
  Case 500: Handle server error

# Complex logic
Condition: (payment_method == "card") AND (card_type == "amex")
  Then: Apply American Express processing

Related: Conditional Execution

🔁 Loop/Iteration Template

Repeat actions multiple times or for each item in a collection.

Structure:

For Each Item in Collection:
  ├─ Process Item 1
  ├─ Process Item 2
  ├─ Process Item 3
  └─ Process Item N

When to Use:

✅ Process multiple items
✅ Data-driven testing
✅ Batch operations
✅ Repeated validations

Template Configuration:

Name: Loop Iteration Template
Pattern: Repetition
Loop Types:
  - For N times
  - For each item in collection
  - While condition true
  - Until condition met

Fixed Iteration:
  Loop: 5 times
    - Step: [Action to repeat]
    - Step: [Validation to repeat]

Collection-based:
  Loop: For each in [collection_variable]
    - Step: Process [current_item]
    - Step: Validate [current_item]

Example Implementation:

Workflow: Add Multiple Items to Cart

Product List: [Product1, Product2, Product3]

Loop: For each product in list
  1. Search for product
  2. Click "Add to Cart"
  3. Verify added (count increments)
  4. Validate product in cart

After Loop:
  1. Go to checkout
  2. Verify all items present

Collection Sources:

# From data file
Collection: data.csv (products)

# From API response
Collection: response.results[]

# From database query
Collection: SELECT * FROM products

# Hardcoded list
Collection: ["Item1", "Item2", "Item3"]

Loop Control:

# Fixed count
Loop: 5 times

# Until success
Loop Until: result == "success"
Maximum Iterations: 10

# While condition
Loop While: items.count > 0

# For each with counter
Loop: For each item (index available)
  Step: Display: "Processing item {{index}} of {{total}}"

⚙️ Error Handling Template

Handle failures gracefully with retries, fallbacks, and error recovery.

Structure:

Try:
  ├─ Attempt action
  ├─ If success → Continue
  └─ If fails → Catch block
Catch:
  ├─ Increment retry counter
  ├─ If retries left → Retry
  └─ If retries exhausted → Execute recovery
Finally:
  └─ Cleanup or logging

When to Use:

✅ Network operations prone to failure
✅ Async operations with timing issues
✅ External service calls
✅ Flaky test scenarios

Template Configuration:

Name: Error Handling Template
Pattern: Try-Catch-Retry
Components:
  - Try Block: Action to execute
  - Catch Block: Error handling
  - Retry Logic: Automatic retry
  - Fallback: Alternative action
  - Finally: Cleanup

Basic Structure:
  Try:
    - Step: [Main action]
    - Step: [Validation]
  Catch ErrorType: [Specific error]
    - Step: [Recovery action]
    - Step: [Log error]
  Retry:
    - Max Attempts: 3
    - Wait Between: 2 seconds
    - Backoff: Exponential

Example Implementation:

Workflow: API Call with Retry

Try:
  1. Call API endpoint
  2. Validate response (200)
  3. Parse response data

Catch: Connection Error
  1. Log error details
  2. Retry up to 3 times
  3. Wait 5 seconds between retries
  4. Exponential backoff (5s, 10s, 20s)

Catch: Invalid Response
  1. Log response details
  2. Check server status
  3. Execute fallback endpoint

Finally:
  1. Log operation results
  2. Clean up resources

Retry Strategies:

# Fixed retry
Retry:
  Max Attempts: 3
  Wait: 5 seconds (fixed)

# Exponential backoff
Retry:
  Max Attempts: 5
  Base Wait: 1 second
  Multiplier: 2 (1s, 2s, 4s, 8s, 16s)

# Jittered retry
Retry:
  Max Attempts: 3
  Base Wait: 2 seconds
  Jitter: Random (2-4s, 4-6s, 6-8s)

# Fibonacci backoff
Retry:
  Max Attempts: 4
  Sequence: 1s, 1s, 2s, 3s, 5s

Error Types to Handle:

Network Errors:
  - Connection timeout
  - DNS failure
  - Network unreachable

Timeout Errors:
  - Request timeout
  - Response timeout
  - Execution timeout

Application Errors:
  - Invalid response
  - Missing data
  - Validation failure

Service Errors:
  - Server error (5xx)
  - Service unavailable
  - Rate limiting

Related: Error Handling

🔀 Decision Tree Template

Complex multi-level decision logic for sophisticated workflows.

Structure:

Initial Decision:
  ├─ Condition A
  │   ├─ Sub-condition A1 → Path A1
  │   └─ Sub-condition A2 → Path A2
  ├─ Condition B
  │   ├─ Sub-condition B1 → Path B1
  │   └─ Sub-condition B2 → Path B2
  └─ Default → Path Default

When to Use:

✅ Multiple conditional branches
✅ Business logic flows
✅ Complex validation rules
✅ Workflow routing

Template Configuration:

Name: Decision Tree Template
Pattern: Multi-level Conditional
Structure:
  Level 1: Primary condition
  Level 2: Secondary conditions per branch
  Level 3: Tertiary conditions (optional)
  Leaf Nodes: Final actions

Example:
  Decision 1: What is user type?
    ├─ Premium User
    │   └─ Decision 2: Order > $100?
    │       ├─ Yes → Apply bulk discount
    │       └─ No → Apply standard discount
    ├─ Standard User
    │   └─ Decision 2: Has coupon?
    │       ├─ Yes → Apply coupon
    │       └─ No → No discount
    └─ Guest User
        └─ Action: Prompt login or continue as guest

Example Implementation:

Workflow: Checkout Flow Decision Tree

1. Decision: Is customer logged in?
   ├─ Yes
   │   └─ Retrieve saved addresses
   │       └─ Decision: Has saved payment?
   │           ├─ Yes → Use saved payment
   │           └─ No → Enter new payment
   └─ No
       └─ Decision: Existing account or new?
           ├─ Login → Retrieve saved data
           └─ New → Collect all details

2. Decision: What shipping method?
   ├─ Standard → 3-5 days
   ├─ Express → 1-2 days
   └─ Overnight → Next day

3. Continue to payment

Related: Conditional Execution

📈 Performance & Load Template

Test system performance and scalability with concurrent requests.

Structure:

Concurrent Executions:
  ├─ Thread 1: User action
  ├─ Thread 2: User action
  ├─ Thread 3: User action
  └─ Thread N: User action

Measurement:
  ├─ Response times
  ├─ Error rates
  ├─ Throughput
  └─ Resource usage

When to Use:

✅ Load and stress testing
✅ Performance benchmarking
✅ Scalability validation
✅ Concurrent user simulation

Template Configuration:

Name: Performance Testing Template
Pattern: Load Testing
Parameters:
  Concurrent Users: 10-100
  Duration: 5-10 minutes
  Ramp-up: Gradual (optional)
  Metrics: Response time, errors, throughput

Configuration:
  Threads: 50 concurrent users
  Ramp-up Time: 2 minutes (gradually add users)
  Duration: 5 minutes (sustained load)
  Think Time: 1-3 seconds (between actions)

Metrics to Capture:
  - Min response time
  - Max response time
  - Average response time
  - 95th percentile
  - 99th percentile
  - Error count
  - Error rate (%)
  - Throughput (requests/sec)

Example Implementation:

Workflow: E-commerce Platform Load Test

Setup:
  - 50 concurrent users
  - Ramp-up: 2 minutes
  - Duration: 10 minutes

User Actions (repeated):
  1. Browse products (5 sec think time)
  2. Search for item (2 sec think time)
  3. View product details (3 sec think time)
  4. Add to cart (1 sec think time)
  5. View cart (2 sec think time)

Measurements:
  - Product listing API response
  - Search API response
  - Product details API response
  - Add to cart API response
  - Server CPU usage
  - Database query times

Performance Targets:

Response Time:
  Acceptable: < 2 seconds
  Good: < 500ms
  Excellent: < 200ms

Error Rate:
  Acceptable: < 1%
  Good: < 0.1%
  Excellent: 0%

Throughput:
  Minimum: 100 requests/sec
  Target: 500 requests/sec
  Peak: 1000 requests/sec

Related: Performance Optimization

🔐 Data-Driven Testing Template

Run same workflow with different test data sets.

Structure:

Test Data Set 1 → Execute Workflow → Record Results
Test Data Set 2 → Execute Workflow → Record Results
Test Data Set 3 → Execute Workflow → Record Results
...
Test Data Set N → Execute Workflow → Record Results

When to Use:

✅ Testing with multiple data scenarios
✅ Boundary value testing
✅ Equivalence partitioning
✅ Regression testing with different inputs

Template Configuration:

Name: Data-Driven Testing Template
Pattern: Parameterized Testing
Data Sources:
  - CSV file
  - Excel spreadsheet
  - Database query
  - JSON file
  - API response

Configuration:
  Data File: test_data.csv
  Test Rows: All or specific range
  Columns: username, password, expected_result

Workflow Steps:
  - For each row in data:
    1. Read: {{username}} from data
    2. Read: {{password}} from data
    3. Execute: Login workflow
    4. Validate: against {{expected_result}}
    5. Record: Pass/Fail

Example Data File (CSV):

username,password,expected_result,test_case
[email protected],ValidPass123,success,Valid credentials
[email protected],InvalidPass,failure,Invalid password
,ValidPass123,failure,Missing username
[email protected],,failure,Missing password
[email protected],ValidPass123,success,Valid credentials 2

Example Implementation:

Workflow: Login Testing with Data-Driven Approach

Test Data:
  - Valid credentials (multiple users)
  - Invalid password scenarios
  - Missing field scenarios
  - Special character scenarios
  - SQL injection attempts
  - Long input strings

Workflow:
  For each test case in data:
    1. Navigate to login
    2. Enter username (from data)
    3. Enter password (from data)
    4. Click login
    5. Validate result (from data)
    6. Record outcome

Report:
  - Total tests: 20
  - Passed: 18
  - Failed: 2
  - Coverage: 95%

Related: Custom Variables

Template Usage Guide

1. Select Appropriate Template

Choose the template matching your workflow structure:

Sequential for simple linear flows
Conditional for branching logic
Loop for repetitive actions
Error Handling for robust workflows

2. Review Template Structure

Understand the template's organization and components before customization.

3. Customize for Your Needs

Replace template placeholders with your:

Application URLs
Test data
Validation logic
Assertions
Timeouts

4. Add Business Logic

Implement your specific:

Test scenarios
Validation rules
Error handling
Performance requirements

5. Test Thoroughly

Execute and validate:

All happy paths work
Error scenarios handled
Performance acceptable
Data integrity maintained

6. Deploy and Monitor

Schedule and monitor your workflow:

Set execution schedule
Configure alerts
Track metrics
Adjust as needed

Template Combination Examples

Complex Workflow: Combining Multiple Templates

Scenario: E-commerce Checkout with Robustness

Workflow: E-commerce Checkout Robust

# Template 1: Sequential (main flow)
1. Navigate to cart
2. Proceed to checkout
3. Enter shipping
4. Select payment
5. Place order

# Template 2: Loop (process multiple items)
Loop through cart items:
  - Validate price
  - Check availability
  - Update quantity

# Template 3: Conditional (shipping logic)
Condition: Order > $100?
  - Yes: Free shipping
  - No: Standard shipping

# Template 4: Error Handling (payment)
Try:
  - Process payment
Catch:
  - Retry up to 3 times
  - Try alternate payment method
Finally:
  - Log transaction

# Template 5: Decision Tree (user type)
If premium user:
  - Apply loyalty discount
  - Expedited shipping
  - VIP support
Else if new user:
  - Apply new customer discount
Else:
  - Standard processing

Template Comparison

Template

Use Case

Complexity

Execution Time

Sequential

Simple linear flows

Low

Fast

Conditional

Branching logic

Medium

Fast

Loop

Repetitive actions

Medium

Variable

Error Handling

Robust workflows

Medium-High

Slower (with retries)

Decision Tree

Complex logic

High

Variable

Performance

Load testing

High

Long

Data-Driven

Multiple scenarios

Medium

Variable

Best Practices for Templates

✅ Template Best Practices

✅ Start with simple template
✅ Gradually add complexity
✅ Use meaningful step names
✅ Include error handling
✅ Add assertions and validations
✅ Document custom logic
✅ Test thoroughly before deploying
✅ Version your templates
✅ Share successful templates with team
✅ Keep templates maintainable

Sample Workflows Workflow Patterns Best Practices

Next Steps

Ready to build workflows from templates?

Explore Sample Workflows | Learn Patterns | Review Best Practices