Create End-to-End Workflows in Business Workflow Test Automation

What You’ll Learn

This guide walks you through creating complete end-to-end business workflows in E2E Test Automation. By the end, you’ll know how to:

• Design and map business processes
• Use the Modeler to build workflows visually
• Add and configure different types of nodes
• Connect nodes to create process flows
• Use variables to pass data between nodes
• Add conditional logic and loops
• Test and debug workflows
• Monitor execution with the Runner

Step 1: Plan Your Workflow

Before opening the Modeler, map out your complete business process on paper or a whiteboard.

Identify the Business Process

What process are you automating?

Ask yourself:

• What is the starting point?
• What is the desired outcome?
• What are all the steps in between?
• Where are the decision points?
• What could go wrong at each step?

Examples of Business Processes:

• User registration and email verification
• Order placement and fulfillment
• Approval workflow with multiple approvers
• Payment processing with notifications
• Data import and validation
• Report generation and distribution

Map Out the Steps

Create a Sequential List:

Example: E-commerce Checkout Process

1. User logs in via UI
2. Validate user session via API
3. User adds product to cart via UI
4. Verify cart contents via API
5. User proceeds to checkout via UI
6. Validate shipping address via API
7. User enters payment info via UI
8. Process payment via Payment API
9. Create order in Order API
10. Reserve inventory in Inventory API
11. Send confirmation email
12. Display confirmation page to user

Identify Node Types Needed

For each step, determine what type of node you’ll use:

Step Analysis:

Step 1: User logs in via UI
→ Node Type: UI Test
→ Required: Login UI test scenario

Step 2: Validate user session via API
→ Node Type: HTTP Request
→ Required: GET /user/session endpoint

Step 4: Verify cart contents via API
→ Node Type: HTTP Request
→ Required: GET /cart endpoint

Step 8: Process payment via Payment API
→ Node Type: HTTP Request
→ Required: POST /payment endpoint
→ Note: May need Wait Activity if payment is async

Step 11: Send confirmation email
→ Node Type: SES Email or Compliance Approval
→ Required: AWS SES credentials

Identify Conditional Logic

Where do decisions happen?

After Payment Processing:
  If payment successful:
    → Continue to order creation
  If payment failed:
    → Send failure email
    → End workflow

After Inventory Check:
  If items in stock:
    → Continue to fulfillment
  If out of stock:
    → Send out-of-stock notification
    → Offer backorder or refund

Identify Variables and Data Flow

What data passes between steps?

Step 1 (Login) produces:
  → userId
  → authToken
  → sessionId

Step 4 (Cart API) produces:
  → cartId
  → itemList
  → cartTotal

Step 8 (Payment) produces:
  → transactionId
  → paymentStatus
  → confirmationNumber

These variables are used in subsequent steps

Create a Visual Diagram

Draw a simple flowchart:

┌─────────────────┐
│   UI: Login     │
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│ API: Get Session│
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│  UI: Add to Cart│
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│ API: Verify Cart│
└────────┬────────┘
         │
         ↓
┌───────┴─────────┐
│   Conditional:  │
│   Items Valid?  │
└────┬──────┬─────┘
     │Yes   │No
     ↓      ↓
   Continue  Error

Step 2: Open the Workflow Modeler

Access the Modeler

1. Navigate to Business Workflow Test Automation in E2E Test Automation
2. Click “Create New Workflow” or “Open Modeler”
3. You’ll see the visual workflow designer canvas

Understand the Modeler Interface

Main Components:

Canvas:

• Large central area where you build the workflow
• Drag and drop nodes here
• Connect nodes to create flow
• Zoom in/out and pan around

Node Library (Left Panel):

• Lists all available node types
• Drag nodes from here onto the canvas
• Organized by category

Properties Panel (Right Panel):

• Shows properties of selected node
• Configure parameters, scripts, and settings
• Appears when you click a node

Toolbar (Top):

• Save workflow
• Validate workflow
• Run workflow
• Undo/redo
• Zoom controls
• Layout options

Canvas Controls:

• Zoom slider
• Fit to screen
• Pan (click and drag empty space)
• Select multiple (shift + click)

Step 3: Add Your First Node

Start Node

Most workflows start with a Start node (may be added automatically):

• Represents the beginning of the workflow
• No configuration usually needed
• All workflows must have one start point

Add a Node from the Library

Method 1: Drag and Drop

1. Find the node type in the Node Library
2. Click and hold on the node
3. Drag it onto the canvas
4. Release to place it

Method 2: Quick Add

1. Right-click on the canvas
2. Select “Add Node”
3. Choose node type from the menu
4. Node appears at cursor location

Example: Adding UI Test Node

1. Locate “UI Test” in Node Library
2. Drag it onto the canvas
3. Position it below the Start node
4. You’ll see the node appear with a default name

Step 4: Configure Node Parameters

Click on the node you just added to open the Properties Panel.

Node Configuration Tabs

Every node has three tabs:

Parameters Tab:

• Node-specific settings
• Required fields for the node to execute
• Varies by node type

Pre-Script Tab:

• JavaScript executed before the node runs
• Optional
• Used for setup, validation, data manipulation

Post-Script Tab:

• JavaScript executed after the node completes
• Optional
• Used for validation, data extraction, assertions

Configure Basic Parameters

Example: Configuring UI Test Node

In the Parameters tab:

Test Suite:

• Select the UI test suite from dropdown
• This is the test suite containing your UI scenario

Test Scenario:

• Select the specific scenario to execute
• This is the recorded UI test you want to run

Test Dataset:

• Select any dataset variables needed
• Optional if using default values

Framework:

• Usually auto-selected
• The testing framework for UI tests (Playwright, etc.)

Node Name:

• Give it a descriptive name
• Example: “User Login Test”

Add a Pre-Script (Optional)

Switch to the Pre-Script tab if you need to prepare data before the node runs.

Example Pre-Script:

// Set up test data before UI test runs
inputs.username = "test.user@example.com";
inputs.password = "TestPass123!";
inputs.testEnvironment = "staging";
 
console.log("Starting UI test with user: " + inputs.username);

Pre-scripts are useful for:

• Setting up test data
• Validating prerequisites
• Logging information
• Calculating values
• Conditional setup

Add a Post-Script (Optional)

Switch to the Post-Script tab to process results after the node completes.

Example Post-Script:

// Extract data from UI test results
if (outputs.testStatus === "passed") {
    inputs.userId = outputs.extractedUserId;
    inputs.sessionToken = outputs.sessionToken;
    console.log("Login successful. User ID: " + inputs.userId);
} else {
    console.error("Login failed: " + outputs.errorMessage);
    throw new Error("Login test failed");
}

Post-scripts are useful for:

• Extracting data from results
• Validating outcomes
• Setting variables for next nodes
• Handling errors
• Logging results

Step 5: Add More Nodes to Build the Flow

Continue adding nodes for each step in your workflow.

Add an HTTP Request Node

Common next step: Call an API to validate something.

1. Drag “HTTP Request” node onto canvas
2. Position it below the previous node
3. Click to configure

Configure HTTP Request Parameters:

Host:

• The API base URL
• Example: https://api.example.com
• Can use variable: ${inputs.apiBaseUrl}

Endpoint Path:

• The specific endpoint
• Example: /user/profile
• Can include variables: /user/${inputs.userId}

Method:

• Select: GET, POST, PUT, PATCH, DELETE
• Example: GET

Authentication Type:

• Predefined Auth: Use saved credentials
• Header Auth: Add auth in headers
• Query Auth: Add auth in query params
• Bearer Token: Use token authentication

Query Params (Optional):

• Add key-value pairs
• Example: include=profile&detailed=true
• Can use variables: userId=${inputs.userId}

Headers (Optional):

• Add request headers
• Example:
  • Key: Content-Type, Value: application/json
  • Key: Authorization, Value: Bearer ${inputs.authToken}

Body (Optional, for POST/PUT/PATCH):

• Request payload
• JSON format
• Can include variables:

  {
    "userId": "${inputs.userId}",
    "action": "updateProfile",
    "data": {
      "email": "${inputs.newEmail}"
    }
  }

HTTP Request Post-Script Example:

// Extract user data from API response
const response = JSON.parse(outputs.responseBody);
 
if (outputs.statusCode === 200) {
    inputs.userName = response.name;
    inputs.userEmail = response.email;
    inputs.accountStatus = response.status;
    console.log("User profile retrieved: " + inputs.userName);
} else {
    throw new Error("Failed to get user profile: " + outputs.statusCode);
}

Add a Conditional Node

When you need branching logic:

1. Drag “Simple Conditional” node onto canvas
2. Position it where decision happens
3. Configure the condition

Configure Simple Conditional:

Condition Field:

• JavaScript boolean expression
• Must evaluate to true or false

Examples:

// Check if user is active
inputs.accountStatus === "active"
 
// Check if cart has items
inputs.cartItemCount > 0
 
// Check if payment succeeded
inputs.paymentStatus === "success" && inputs.transactionId !== null
 
// Multiple conditions
inputs.userRole === "admin" && inputs.accountAge > 30
 
// Check variable exists
typeof inputs.orderId !== 'undefined' && inputs.orderId !== null

Conditional node has two outputs:

• True: Connects to nodes that execute when condition is true
• False: Connects to nodes that execute when condition is false

Add a Wait Activity Node

When you need to pause execution:

1. Drag “Wait Activity” node onto canvas
2. Configure wait duration

Configure Wait Activity:

Duration:

• Time to wait in milliseconds
• Examples:
  • 1 second: 1000
  • 5 seconds: 5000
  • 1 minute: 60000
  • Can use variable: ${inputs.waitTime}

Use Cases:

• Wait for asynchronous operation to complete
• Simulate user think time
• Allow email delivery before checking
• Rate limiting between API calls
• Wait for background processing

Example:

HTTP Request: Initiate payment processing
  ↓
Wait Activity: 5 seconds
  ↓
HTTP Request: Check payment status

Add an Email Node

For sending notifications:

SES Email Node:

1. Drag “SES Email” onto canvas
2. Configure email settings

Configure SES Email:

AWS Credentials:

• SES credentials for sending
• Usually pre-configured in E2E Test Automation

Source Email:

• From address
• Example: noreply@example.com
• Must be verified in AWS SES

To Email:

• Recipient address
• Can use variable: ${inputs.userEmail}
• Can be comma-separated for multiple: user1@ex.com,user2@ex.com

Subject:

• Email subject line
• Can include variables: Order Confirmation - #${inputs.orderNumber}

Body:

• Email content
• Can be plain text or HTML
• Can include variables:

  <html>
    <body>
      <h1>Hello ${inputs.userName}!</h1>
      <p>Your order #${inputs.orderNumber} has been confirmed.</p>
      <p>Total: $${inputs.orderTotal}</p>
    </body>
  </html>

Step 6: Connect Nodes to Create Flow

Nodes need to be connected to define the execution order.

Create Connections

Method 1: Click and Drag

1. Click on the output port of a node (small circle on the right side)
2. Drag to the input port of the next node (small circle on the left side)
3. Release to create connection
4. A line appears connecting the nodes

Method 2: Auto-Connect

1. Select a node
2. Hover over the output port
3. Click the ”+” icon that appears
4. Select the next node from the menu
5. Connection is created automatically

Connection Rules

Sequential Flow:

• Simple: Node A → Node B → Node C
• Each node waits for the previous to complete

Conditional Branches:

• Conditional nodes have two output ports:
  • True output (top/right)
  • False output (bottom/right)
• Connect each to different nodes

Example:

Simple Conditional: Payment Success?
  ├─ True → HTTP Request: Create Order
  └─ False → SES Email: Payment Failed Notification

Merging Branches:

• Multiple nodes can connect to the same next node
• Useful for joining conditional branches

Example:

Conditional: Stock Available?
  ├─ True → HTTP Request: Reserve Inventory
  │           ↓
  └─ False → HTTP Request: Backorder Item
              ↓
     ┌────────┴────────┐
    SES       Email: Confirmation

Step 7: Use Variables for Data Flow

Variables allow data to pass between nodes.

Variable Syntax

Access variables using:

${inputs.variableName}

Examples:

${inputs.userId}
${inputs.orderTotal}
${inputs.confirmationEmail}
${inputs.authToken}

Setting Variables in Scripts

In Pre-Script or Post-Script:

// Set a variable
inputs.userId = "12345";
inputs.orderTotal = 99.99;
inputs.isAdmin = true;
 
// Set from API response
const response = JSON.parse(outputs.responseBody);
inputs.userId = response.data.id;
inputs.userName = response.data.name;
 
// Set from calculation
inputs.taxAmount = inputs.orderSubtotal * 0.08;
inputs.orderTotal = inputs.orderSubtotal + inputs.taxAmount;
 
// Set from conditional logic
if (response.accountType === "premium") {
    inputs.discountPercent = 20;
} else {
    inputs.discountPercent = 10;
}

Using Variables in Node Parameters

In HTTP Request URL:

https://api.example.com/users/${inputs.userId}/orders

In HTTP Request Body:

{
  "userId": "${inputs.userId}",
  "amount": ${inputs.orderTotal},
  "currency": "USD"
}

In Email Subject:

Order Confirmation - #${inputs.orderNumber}

In Email Body:

<p>Hello ${inputs.userName},</p>
<p>Your order for $${inputs.orderTotal} has been confirmed.</p>

In Conditional:

inputs.orderTotal > 100 && inputs.userStatus === "premium"

Variable Scope

Variables persist throughout workflow:

• Set once, available in all subsequent nodes
• Overwriting a variable updates it for all following nodes
• Variables don’t carry over to separate workflow executions

Step 8: Add Advanced Features

Loops

Loop Over Items Node:

Use when you need to repeat actions multiple times.

Configure Loop:

Iteration Count:

• How many times to repeat
• Example: 5 for 5 iterations
• Can use variable: ${inputs.retryCount}

Loop Body:

• Connect nodes inside the loop
• These nodes execute each iteration

Example Use Case: Retry API Call

Loop Over Items: Retry 3 times
  Inside loop:
    HTTP Request: Check payment status
    Simple Conditional: Payment complete?
      True → Exit loop
      False → Wait Activity: 2 seconds → Continue loop

Accessing Loop Counter:

// In pre-script or post-script
console.log("Iteration: " + inputs.loopIndex);
 
// Loop index starts at 0
if (inputs.loopIndex === 2) {
    console.log("Last attempt");
}

Event Conditionals with Timeout

Event Conditional Node:

Use when waiting for an event with a timeout.

Configure Event Conditional:

Timeout:

• Maximum wait time
• Units: milliseconds, seconds, minutes, hours, days, months
• Example: 5 minutes, 2 hours, 1 day

Condition:

• Same as Simple Conditional
• JavaScript boolean expression

Behavior:

• Waits for condition to become true
• If condition becomes true → continues on True path
• If timeout expires → continues on False (timeout) path

Example: Approval Workflow

Event Conditional: Wait for approval (timeout: 2 days)
  Condition: inputs.approvalStatus === "approved"
  
  True → Approval received within 2 days → Continue process
  False → Timeout expired → Send reminder or escalate

Signals

Signal Node:

Use to coordinate between parallel workflows or trigger events.

Configure Signal:

Signal Name:

• Unique identifier for the signal
• Example: payment_completed, order_ready

Purpose:

• Send a signal when this node executes
• Other workflows can wait for this signal
• Useful for coordinating dependent processes

Example:

Workflow A:
  HTTP Request: Create Order
  ↓
  Signal: Send "order_created"
  
Workflow B (running separately):
  Wait for Signal: "order_created"
  ↓
  HTTP Request: Start fulfillment

Database Queries

Database Node:

Execute MongoDB database queries.

Configure Database:

Query:

• MongoDB query syntax
• Can use variables

Examples:

Find Document:

db.orders.find({ userId: "${inputs.userId}" })

Insert Document:

db.orders.insert({
  userId: "${inputs.userId}",
  total: ${inputs.orderTotal},
  status: "pending",
  createdAt: new Date()
})

Update Document:

db.orders.update(
  { orderId: "${inputs.orderId}" },
  { $set: { status: "completed" } }
)

Post-Script to Process Results:

// Parse database query results
const result = JSON.parse(outputs.queryResult);
 
if (result.length > 0) {
    inputs.orderExists = true;
    inputs.orderStatus = result[0].status;
} else {
    inputs.orderExists = false;
}

Step 9: Validate Your Workflow

Before running, validate that the workflow is correctly configured.

Visual Validation

Check the flow visually:

• All nodes are connected
• No orphaned nodes (not connected to anything)
• Conditional branches go to appropriate nodes
• Flow starts at a Start node
• Flow ends at logical conclusion(s)

Use the Validation Tool

Click “Validate” in the toolbar:

Validation checks:

• All required parameters are filled
• Variables are properly formatted
• Connections are valid
• No circular dependencies
• Scripts have valid syntax

Common Validation Errors:

Missing Required Parameters:

Error: HTTP Request node "Get User" missing Host parameter
Fix: Add the API host URL

Invalid Variable Reference:

Error: Variable ${inputs.userID} not set in any previous node
Fix: Check spelling (userId vs userID) or set the variable earlier

Disconnected Node:

Warning: Node "Send Email" is not connected
Fix: Connect it to the workflow

Circular Dependency:

Error: Circular dependency detected
Fix: Remove the connection creating the loop

Step 10: Save Your Workflow

Save frequently to avoid losing work:

1. Click “Save” button in toolbar
2. Give the workflow a name if it’s new:
   • Name: Descriptive name (e.g., “E-commerce Checkout Process”)
   • Description: What the workflow tests
   • Tags: For organization (e.g., “checkout”, “critical”, “e-commerce”)
3. Click “Save”

Workflow is now saved and ready to run.

Step 11: Test Your Workflow

Run the Workflow

1. Click “Run” button in the Modeler
   • Or switch to the Runner tab
2. Click “Start Execution”
3. Monitor execution in real-time

Monitor Execution

In the Runner, you’ll see:

Current Status:

• Which node is currently executing
• Progress through the workflow
• Visual highlighting of active node

Execution Log:

• Real-time log messages
• Console.log output from scripts
• Node start/complete messages
• Any errors or warnings

Variable Values:

• Current values of all variables
• Updated as workflow progresses
• Useful for debugging

Node Status:

• ✓ Completed successfully (green)
• ⏳ Currently executing (yellow)
• ✗ Failed (red)
• ⏸ Waiting (gray)

Review Results

After execution completes:

Execution Summary:

• Overall status: Success or Failed
• Total execution time
• Number of nodes executed
• Any errors encountered

Node-by-Node Results:

• Click each node to see details
• View inputs and outputs
• Check API responses
• Review script execution logs

Variable Final State:

• All variable values at end of workflow
• Useful for validation

Step 12: Debug and Refine

If the workflow fails or doesn’t behave as expected:

Identify the Failing Node

Check the Runner:

• Failed nodes are marked in red
• Click the failed node to see details

Review Error Messages

Common errors:

HTTP Request Failed:

Error: HTTP Request to https://api.example.com/users failed
Status: 401 Unauthorized

Fix: Check authentication, credentials, or API endpoint

Variable Not Found:

Error: Variable ${inputs.userId} is undefined

Fix: Ensure the variable is set in a previous node’s post-script

Script Error:

Error in Post-Script: SyntaxError: Unexpected token

Fix: Check JavaScript syntax in the post-script

Timeout:

Error: Node "Check Payment Status" timed out after 30 seconds

Fix: Increase timeout or check why the operation is slow

Use Console Logs for Debugging

Add console.log statements in scripts:

// Pre-Script
console.log("Starting payment with amount: " + inputs.orderTotal);
console.log("User ID: " + inputs.userId);
 
// Post-Script
console.log("Payment response: " + outputs.responseBody);
console.log("Status code: " + outputs.statusCode);
 
const response = JSON.parse(outputs.responseBody);
console.log("Transaction ID: " + response.transactionId);

View logs in the Runner to see what’s happening at each step.

Test Individual Nodes

Isolate problematic nodes:

1. Create a simple test workflow with just that node
2. Test it independently
3. Verify parameters and scripts
4. Once working, integrate back into main workflow

Adjust and Re-Run

1. Make fixes to the workflow
2. Save changes
3. Run again
4. Repeat until workflow completes successfully

Best Practices for Creating Workflows

Design Principles

Keep It Simple:

• Start with a minimal workflow
• Add complexity gradually
• Don’t try to handle every edge case initially

Use Descriptive Names:

• Node names should describe what they do
• “Get User Profile” not “HTTP Request 1”
• Helps with understanding and debugging

Add Comments:

• Use node descriptions to document purpose
• Add comments in scripts
• Document any non-obvious logic

Handle Errors:

• Add conditional checks for failures
• Provide alternative paths
• Send notifications on errors

Validate Data:

• Check that required data exists before using it
• Validate API responses
• Add assertions in post-scripts

Variable Management

Use Consistent Naming:

• camelCase: userId, orderTotal, confirmationEmail
• Descriptive: paymentTransactionId not ptid

Set Variables Early:

• Set all required variables before they’re needed
• Check for undefined variables in conditionals

Don’t Overuse Variables:

• Only create variables for data that’s reused
• Clean, focused variable list is easier to manage

Script Best Practices

Keep Scripts Short:

• Simple logic only
• Complex operations should be separate nodes

Use Try-Catch:

try {
    const response = JSON.parse(outputs.responseBody);
    inputs.userId = response.data.id;
} catch (error) {
    console.error("Failed to parse response: " + error);
    throw error;
}

Validate Before Using:

if (outputs.statusCode === 200) {
    const response = JSON.parse(outputs.responseBody);
    inputs.userId = response.data.id;
} else {
    throw new Error("API call failed with status: " + outputs.statusCode);
}

Testing Strategy

Test Incrementally:

1. Build a few nodes
2. Test that section
3. Add more nodes
4. Test again

Don’t build entire workflow before first test.

Test Edge Cases:

• What if API returns 500?
• What if payment times out?
• What if user doesn’t exist?
• What if cart is empty?

Use Realistic Test Data:

• Don’t use hardcoded test values in production workflows
• Use variables for flexibility
• Test with data similar to production

Example: Complete Workflow Creation

Let’s walk through creating a complete workflow for User Registration with Email Verification.

Business Process

1. User fills registration form (UI)
2. Create user account (API)
3. Verify account was created (Database)
4. Send verification email (Email)
5. Wait for user to click verification link (Wait)
6. Verify email address (API)
7. Send welcome email (Email)
8. Display success message (UI)

Step-by-Step Creation

Step 1: Add UI Test Node - Registration Form

• Name: “User Registration Form”
• Configure: Select UI test suite and registration scenario
• Post-Script:

  inputs.userEmail = outputs.registeredEmail;
  inputs.userId = outputs.newUserId;

Step 2: Add HTTP Request Node - Create Account API

• Name: “Create User Account”
• Host: ${inputs.apiHost}
• Endpoint: /users
• Method: POST
• Body:

  {
    "email": "${inputs.userEmail}",
    "password": "${inputs.userPassword}",
    "firstName": "${inputs.firstName}",
    "lastName": "${inputs.lastName}"
  }

• Post-Script:

  const response = JSON.parse(outputs.responseBody);
  if (outputs.statusCode === 201) {
      inputs.userId = response.userId;
      inputs.verificationToken = response.verificationToken;
  } else {
      throw new Error("Failed to create user");
  }

Step 3: Add Database Node - Verify User Created

• Name: “Verify User in Database”
• Query:

  db.users.find({ email: "${inputs.userEmail}" })

• Post-Script:

  const result = JSON.parse(outputs.queryResult);
  if (result.length === 0) {
      throw new Error("User not found in database");
  }
  inputs.userAccountStatus = result[0].status;

Step 4: Add SES Email Node - Send Verification Email

• Name: “Send Verification Email”
• From: noreply@example.com
• To: ${inputs.userEmail}
• Subject: Verify your email address
• Body:

  <p>Hi ${inputs.firstName},</p>
  <p>Please verify your email by clicking this link:</p>
  <a href="https://example.com/verify?token=${inputs.verificationToken}">Verify Email</a>

Step 5: Add Wait Activity Node - Simulate Email Click Delay

• Name: “Wait for Email Verification”
• Duration: 10000 (10 seconds for testing, could be longer in reality)

Step 6: Add HTTP Request Node - Verify Email API

• Name: “Verify Email Address”
• Host: ${inputs.apiHost}
• Endpoint: /users/${inputs.userId}/verify
• Method: POST
• Body:

  {
    "token": "${inputs.verificationToken}"
  }

• Post-Script:

  if (outputs.statusCode === 200) {
      inputs.emailVerified = true;
  } else {
      throw new Error("Email verification failed");
  }

Step 7: Add Simple Conditional - Check Verification

• Name: “Email Verified?”
• Condition: inputs.emailVerified === true

Step 8a: Add SES Email Node - Welcome Email (True branch)

• Name: “Send Welcome Email”
• From: noreply@example.com
• To: ${inputs.userEmail}
• Subject: Welcome to Example.com!
• Body:

  <h1>Welcome ${inputs.firstName}!</h1>
  <p>Your account is now verified and ready to use.</p>

Step 8b: Add SES Email Node - Failed Verification (False branch)

• Name: “Send Verification Failed Email”
• Similar configuration with failure message

Step 9: Add UI Test Node - Success Page

• Name: “Display Success Message”
• Configure: Select UI test that verifies success message appears

Connect All Nodes

1. Connect nodes in sequence as numbered
2. Connect conditional True to Welcome Email
3. Connect conditional False to Failed Email
4. Both email nodes connect to Success Page UI test

Save and Test

1. Save workflow as “User Registration with Email Verification”
2. Run workflow
3. Monitor execution
4. Verify all nodes complete successfully
5. Check that emails are sent
6. Validate user is created in database

Summary

Creating end-to-end workflows in Business Workflow Test Automation involves:

1. Planning the workflow - Map out your business process
2. Using the Modeler - Visual interface for building workflows
3. Adding nodes - Drag and drop different node types
4. Configuring nodes - Set parameters, pre-scripts, post-scripts
5. Connecting nodes - Define execution flow
6. Using variables - Pass data between nodes
7. Adding logic - Conditionals, loops, waits
8. Validating - Ensure workflow is correct
9. Testing - Run and monitor execution
10. Debugging - Fix issues and refine

Key Principles:

• Start simple, add complexity gradually
• Use descriptive names and comments
• Test incrementally
• Handle errors gracefully
• Use variables effectively
• Monitor and debug with logs

You’re now ready to create sophisticated end-to-end workflows that validate your complete business processes!