Step 1: Identify failing step
[Check execution logs]
[Note step name and position]
Step 2: Review step configuration
[Open step details]
[Verify all settings correct]
[Check required fields filled]
Step 3: Check step input
[View output from previous step]
[Verify data passed correctly]
[Check data format/type]
Step 4: Test step independently
[Create test workflow with just this step]
[Execute with same inputs]
[Verify failure repeats]
Verify Configuration:
[Check all required fields]
[Fix any misconfigurations]
[Test with valid values]
Fix Input Data:
[Verify previous step output]
[Format data if needed]
[Add data transformation if required]
Check Service Availability:
[Test endpoint manually]
[Verify API key valid]
[Check service status]
Add Error Handling:
[Add retry logic]
[Add error handler]
[Implement fallback]
Step 1: Verify expected result
[Review requirement]
[Note exact expected value]
[Check test data]
Step 2: Compare with actual result
[View execution results]
[Check each output]
[Find first difference]
Step 3: Trace data flow
[Follow data through steps]
[Check transformations]
[Verify calculations]
Step 4: Test with simpler data
[Use minimal test case]
[Execute with known data]
[Verify still wrong]
Fix Logic:
[Review workflow logic]
[Check conditional statements]
[Fix boolean logic if needed]
Fix Data Transformation:
[Verify transformation correct]
[Test transformation independently]
[Add logging for transparency]
Fix Assertion:
[Review expected vs actual]
[Adjust assertion if needed]
[Add more detailed checks]
Handle Race Condition:
[Add explicit ordering]
[Add synchronization]
[Add delays if needed]
Step 1: Verify previous step executed
[Check previous step status]
[Verify step marked "Passed"]
[Check step output]
Step 2: Check variable name
[Note variable name in source step]
[Note variable name in target step]
[Verify they match exactly]
Step 3: Check variable scope
[Verify variable scope setting]
[Global scope: accessible everywhere]
[Workflow scope: accessible in workflow]
[Step scope: only in step]
Step 4: Verify data saved
[Check data hub for saved data]
[Verify save step executed]
[Check save was successful]
Fix Variable Name:
[Use exact variable name]
[Check case sensitivity]
[Use proper syntax: ${variable_name}]
Fix Variable Scope:
[Set to correct scope]
[Global for all workflows]
[Workflow for single workflow]
Fix Data Passing:
[Add explicit data passing step]
[Use Data Hub for storage]
[Add logging to verify passing]
Example:
Step 1: user_id = 123
Step 2: ${user_id} ← Use this syntax
Step 1: Check storage method
[Session persistence: within execution]
[Data hub: across executions]
[Using correct type?]
Step 2: Verify data saved
[Check save operation logged]
[Verify no errors in save]
[Check data stored]
Step 3: Check retrieval
[Attempt to retrieve data]
[Verify correct key]
[Check data hub contents]
Step 4: Check timing
[When is session cleared?]
[When is data hub cleared?]
[Execution order?]
Use Data Hub for Persistence:
Step 1: Save
[Data Hub: Set {key: "user_id", value: 123}]
Step 2 (later):
[Data Hub: Get {key: "user_id"}]
value = 123 (retrieved successfully)
Use Session for Temporary:
Within single execution:
[Store in session]
[Accessible across steps]
[Cleared after execution]
Manual Data Persistence:
[Export to file]
[Save to database]
[External storage]
Step 1: Measure execution time
[Note total time]
[Note individual step times]
[Identify slowest step]
Step 2: Analyze slow step
[What does it do?]
[How much data processed?]
[Is it waiting?]
Step 3: Check execution efficiency
[Are steps sequenced efficiently?]
[Are there unnecessary waits?]
[Current execution efficiency?]
Step 4: Check external services
[API response times]
[Database query times]
[Network latency]
Optimize Steps:
FROM:
[Step 1] → [Step 2] → [Step 3]
(Total: 30 seconds)
TO:
[Optimized sequence]
├─ [Step 1]
├─ [Step 2]
└─ [Step 3]
(Total: 20 seconds)
Optimize Data Retrieval:
❌ Fetch all data: 1000 records (10 sec)
✅ Fetch specific: 10 records (1 sec)
Remove Unnecessary Waits:
❌ Wait 30 seconds: hardcoded
✅ Wait until condition: actual time
Cache Data:
❌ Fetch from API each time (5 sec each)
✅ Store in Data Hub (reuse)
Check External Services:
[Test API endpoint speed]
[Check database performance]
[Optimize queries]
Step 1: Check data size
[How much data processed?]
[Memory available?]
[Ratio acceptable?]
Step 2: Check execution concurrency
[How many workflows running?]
[Total resources needed?]
[Exceeds system capacity?]
Step 3: Monitor memory usage
[Peak memory used?]
[When peak occurs?]
[Trend over time?]
Process Data in Chunks:
❌ All 1 million records at once
✅ Process 1000 at a time (loop)
Manage Execution Load:
❌ 100 concurrent executions
✅ 10 concurrent executions
Use Streaming:
❌ Load entire file to memory
✅ Stream file processing
Optimize Code:
[Remove unnecessary variables]
[Clear large objects after use]
[Use smaller data types]
Step 1: Verify endpoint
[Is URL correct?]
[Is service online?]
[Check API status page]
Step 2: Test endpoint manually
[Use curl or Postman]
[Same URL as workflow]
[Same headers/parameters]
[Verify response]
Step 3: Check credentials
[API key valid?]
[Token not expired?]
[Permissions correct?]
Step 4: Check network
[Can you reach endpoint?]
[Firewall blocking?]
[Proxy required?]
Verify URL:
[Check for typos]
[Include protocol (https://)]
[Check port number]
Update Credentials:
[Regenerate API key]
[Update token]
[Verify permissions]
Handle Network Issues:
[Configure proxy if needed]
[Check firewall rules]
[Verify VPN if required]
Add Error Handling:
[Implement retry logic]
[Add fallback endpoint]
[Implement circuit breaker]
Verify Connection String:
Correct format:
postgresql://user:pass@localhost:5432/db_name
mysql://user:pass@localhost:3306/db_name
mongodb://user:pass@localhost:27017/db_name
Update Credentials:
[Verify username/password]
[Check user permissions]
[Reset password if needed]
Check Database Status:
[Start database service]
[Check for errors in logs]
[Verify port accessible]
Add Retry Logic:
[Retry on connection failure]
[Implement backoff]
[Add timeout]
Step 1: Verify credentials
[Check API key is correct]
[Check if key expired]
[Verify format]
Step 2: Check permissions
[Does key have required scope?]
[Does user have permissions?]
[Admin rights needed?]
Step 3: Test credentials directly
[Use curl with credentials]
[Test basic auth]
[Verify key format]
Step 4: Check headers
[Correct header format?]
[Authorization header present?]
[Case sensitivity?]
Fix Credentials:
[Regenerate API key]
[Update in workflow]
[Verify format correct]
Add Bearer Token:
Authorization: Bearer YOUR_TOKEN
Add Basic Auth:
Authorization: Basic base64(user:pass)
Check Permissions:
[Verify scope granted]
[Request additional scope]
[Use admin key if available]
Store Securely:
[Use environment variables]
[Never hardcode credentials]
[Use credential store]
Step 1: Verify variable is set
[Check environment variables]
[Verify name correct]
[Check value present]
Step 2: Check variable reference
[Verify syntax: ${VAR_NAME}]
[Check for typos]
[Check case matches]
Step 3: Test variable access
[Log variable value]
[Verify not null]
[Check in execution logs]
Step 4: Check scope
[Is variable accessible in workflow?]
[Global vs local scope?]
[Proper scope selected?]
Set Environment Variable:
Linux/macOS:
export MY_VAR="value"
Windows:
set MY_VAR=value
Reference in Workflow:
✅ Correct: ${MY_VAR}
❌ Wrong: $MY_VAR or MY_VAR
Verify in Logs:
[Add logging step]
[Print ${MY_VAR}]
[Verify value in output]
Set Default Value:
[If not set, use default]
${MY_VAR:-default_value}
1. Verify workflow ID correct
2. Check workflow still exists
3. Verify access permissions
4. Create new workflow if deleted
1. Request access from admin
2. Check user role
3. Verify project access
4. Check resource permissions
1. Check service status page
2. Wait for service recovery
3. Implement retry logic
4. Use fallback service if available
1. Check parameter format
2. Verify parameter type matches
3. Check for required fields
4. Validate before passing
1. Increase timeout setting
2. Check service performance
3. Verify network connectivity
4. Add retry logic with backoff
1. Network latency
2. Service response time
3. Database query performance
4. Execution efficiency opportunities
5. Resource constraints
1. Use caching where possible
2. Optimize independent steps
3. Optimize queries/API calls
4. Reduce data transfer
5. Use appropriate data structures
