Execute code in Python, JavaScript (Node.js), PowerShell, Bash, or Go inside isolated Docker containers. Each language has its own package management: PyPI, npm, or PowerShell Gallery.

Example: Process Health Check Data

import json

# Access context variables passed from previous steps
health_data = json.loads('''{{{{ raw_health_json }}}}''')

# Process the data
critical_services = [
    s for s in health_data.get('services', [])
    if s.get('status') == 'down'
]

# Return result as JSON string
result = {
    'total_services': len(health_data.get('services', [])),
    'critical_count': len(critical_services),
    'needs_alert': len(critical_services) > 0
}

print(json.dumps(result))

Call external HTTP endpoints with context variable interpolation.

Example: Fetch Customer Data

Connector: "External API"
Method: GET
URL: https://api.example.com/customers/{{{{ webhook_payload.customer_id }}}}
Headers:
  Authorization: Bearer {{{{ CUSTOMER_API_KEY }}}}
  
Body (for POST):
  {
    "email": "{{{{ webhook_payload.email }}}}",
    "action": "update_profile"
  }

Execute SQL queries against PostgreSQL or MySQL with interpolated context.

Example: Log Workflow Execution

Connector: "Main Database"
Query:
INSERT INTO audit_log (
  user_id, action, timestamp, details
) VALUES (
  {{{{ webhook_payload.user_id }}}},
  'workflow_executed',
  NOW(),
  '{{{{ json.dumps(audit_details) }}}}'
)
RETURNING id, created_at;

Python expressions to shape and combine data from previous steps.

Example: Format Report

# Variables from previous steps are in scope
result = {
    'is_healthy': health_data.get('critical_count', 0) == 0,
    'total_errors': len(error_log),
    'success_rate': (
        (customer_count - error_count) / customer_count * 100
        if customer_count > 0 else 0
    ),
    'timestamp': datetime.now().isoformat(),
    'report': f"""Health Check Report
    Status: {'OK' if health_data.get('critical_count', 0) == 0 else 'CRITICAL'}
    Errors: {len(error_log)}
    Customers Processed: {customer_count}
    """
}
print(json.dumps(result))

Send alerts via Email, Teams, Slack, Discord, Telegram, and more.

Example: Alert on Critical Issues

Connector: "Slack - #alerts"
Subject: Service Health Alert
Message: 
  Critical Services Down:
  {{{{ health_data.critical_services_list }}}}
  
  Timestamp: {{{{ now }}}}
  Action: Review dashboard at
  https://dashboard.example.com

Branch workflow execution based on boolean expressions.

Example: Route by Status

Expression:
  health_data.get('critical_count', 0) > 0

True Branch (Critical Issues Found):
  └─ Step 1: Send Urgent Slack Alert
  └─ Step 2: Create Incident (API call)
  └─ Step 3: Page On-Call Engineer

False Branch (Everything OK):
  └─ Step 1: Log Success to Database
  └─ Step 2: Send Digest Email

Each branch can contain multiple sub-steps, creating complex workflows.

Pause workflow execution and wait for human approval before continuing. Supports multiple designated approvers with email notifications and full audit trail.

Key Features

• Multi-Approver — Designate multiple approvers per step (org members + free-text emails)
• Email Notifications — Sends approval request emails via configured connectors
• Comment & Audit — Approvers can leave comments; every action is logged
• Timeout — Auto-expire after configurable hours/days
• MCP / CLI — Approve or reject from LLM chat or the command line

Example: Deployment Gate

Step: "Request Deployment Approval"
Type: approval

Config:
  Approver(s): ops-lead@company.com, cto@company.com
  Required Approvals: 1
  Timeout: 24 hours
  Require Comment: true
  Subject: "Approval required for {{workflow_name}}"
  Message: "Production deployment ready for review."

Behaviour:
  → Sends email to all designated approvers
  → Workflow pauses and polls every 10 seconds
  → First approver to approve/reject decides outcome
  → On approval: workflow continues to next step
  → On rejection: workflow fails with reason
  → On timeout: workflow fails as expired

Approvers are snapshotted per request — changing the config later won't affect in-flight approvals.

Invoke another workflow as a child step within the parent. Map inputs from current context and receive merged results.

Example: Call Data Enrichment Sub-Workflow

Step: "Enrich Customer Data"
Type: subflow

Config:
  Sub-Workflow: "data-enrichment-pipeline"
  Input Mapping:
    {
      "customer_id": "{{webhook_payload.id}}",
      "source": "crm"
    }

Behaviour:
  → Runs the child workflow with mapped inputs
  → Child steps execute with label prefix [SubFlow: ...]
  → Result merged back as subflow_{step_label} keys
  → Parent continues with enriched context

Pause workflow execution for a specified number of seconds (max 300). Useful for rate limiting or waiting for external processes.

Example: Wait Before Retry

Step: "Wait for External System"
Type: delay

Config:
  Seconds: 30
  Message: "Waiting for payment processor to settle..."

Output:
  delay_duration: 30
  delay_message: "Waiting for payment processor to settle..."

Map context variables to a structured workflow output. The mappings are persisted to the Job record as workflow_output and returned via the API.

Example: Return Report Summary

Step: "Return Results"
Type: output

Config:
  Mappings:
    "total_processed": "batch_result.count"
    "errors": "validation_step.error_list"
    "report_url": "upload_step.public_url"

→ Supports dot-notation for nested data
→ Result saved to Job.workflow_output

Iterate over an array from a previous step and execute sub-steps for each element. Each iteration has access to the current item.

Example: Process Each Order

Step: "Process Orders"
Type: loop

Config:
  Array Source: "fetch_orders.data"
  Item Variable: "current_order"
  Sub-Steps:
    └─ Step 1: Validate order (Script)
    └─ Step 2: Update inventory (Database)
    └─ Step 3: Send confirmation (Notification)

❓ "Output Variable Not Found" Error

Cause: Trying to use an output variable from a later step, or step hasn't been executed yet.

Solution: Verify the step that creates the variable has been executed before the step trying to use it.

Correct order:
Step 1: fetch_data (Output: "results")
Step 2: use {{results.field}} in condition
Step 3: use {{results.field}} in next step

Wrong order:
Step 1: use {{results.field}} ← Error! results doesn't exist yet
Step 2: fetch_data (Output: "results")

❓ "Context Variable Not Available" in Script Step

Cause: Trying to use context variable syntax {{var}} in script code (Python doesn't parse {{}} syntax).

Solution: Access context variables directly by name in Python, or pass via script args.

Wrong in Script Step code:
message = "User: {{user_email}}"

Correct way 1 (from args):
# Script Args: --email {{webhook_payload.email}}
import sys
email = sys.argv[sys.argv.index('--email') + 1]

Correct way 2 (via Environment):
import os
email = os.getenv('USER_EMAIL')
# Pass via step config

❓ API Step Returns Empty Response

Cause: API endpoint not accessible, authentication failed, or malformed request.

Solution: Check job logs for actual API error. Verify:

• URL is correct (no typos, proper interpolation)
• Authentication headers are included (API key, Bearer token)
• Request body is valid JSON
• External API is reachable from your network

❓ Scheduled Workflow Not Running

Cause: Workflow not enabled, cron expression wrong, or scheduler service not running.

Solution:

• Verify "is_active" is enabled for the workflow
• Test cron expression at crontab.guru
• Check scheduler logs: docker logs pyexec-scheduler-1
• Click "Run Now" to verify workflow itself works

❓ Database Step Fails with Encoding Error

Cause: Non-UTF8 characters in context variable data being inserted into database.

Solution: Use Transform step to clean data before database insert:

Transform Step before Database:
# Clean non-UTF8 characters
cleaned = user_data.get('name', '').encode('utf-8', 'ignore').decode('utf-8')
result = {'clean_name': cleaned}

🔍 How to Debug

1. Check Job Logs: Click on failed job to see detailed logs with full context
2. Enable Debug Mode: Add verbose logging to script steps
3. Test Step Isolation: Create a test workflow with just one step to verify it works
4. Print Context: Use Transform steps to inspect variable contents before using them
5. Verify Secrets: Ensure secrets are stored correctly (they don't show their values in logs)