Automation Quick Fix

Fast-track resolver for common automation workflow error patterns across multiple platforms with immediate, proven solutions.

Supported Platforms

• Power Automate (Microsoft)

• n8n (Open-source)

• Make (formerly Integromat)

• Zapier

• Other JSON-based workflow platforms

Purpose

Provides rapid fixes for frequently encountered automation workflow errors across all platforms:

• Authentication errors (401/403)

• Throttling errors (429)

• Data format issues (JSON parsing, data transformation)

• Timeout errors

• Not found errors (404)

• Basic expression/formula errors

When to use this skill: Error matches a well-known pattern When to use automation-debugger instead: Unknown error, complex scenario, or quick fix doesn't resolve

Activation Triggers

Activates for messages like:

• "Quick fix for 429 error in SharePoint/API/webhook"

• "Fast solution for authentication error in n8n"

• "I'm getting throttled in Make, need immediate fix"

• "Parse JSON is failing in Zapier, quick help"

• "Function expects one parameter but was invoked with 2"

• "Unable to process template language expressions"

• "Fix this expression/filter/query/condition"

• User provides code snippet and asks for "quick fix" or "fix this"

• Status codes: 401, 403, 404, 429 with platform/connector context

• Platform-specific: "n8n node error", "Make scenario failing", "Power Automate action issue"

⚠️ IMPORTANT: Data Structure Check (NEW!)

Before applying any quick fix, quickly verify data structures in your flow:

Quick Data Type Check

// In filters/queries, check the where clause:

// Array of STRINGS (primitives): "where": "@contains(item(), 'text')" // ← item() without property

// Array of OBJECTS: "where": "@contains(item()?['Name'], 'text')" // ← item()?['Property']

If your flow has data structure mismatches (filter uses item() but loop uses items('Loop')?['Property'] ), this is NOT a quick fix scenario → use automation-debugger instead.

Quick Fix applies to: Authentication, throttling, timeouts, parse JSON, NOT structural bugs.

Quick Fix Patterns

Data Structure Mismatch (Quick Check - NEW!)

Pattern Recognition:

• Error: "Cannot evaluate property on undefined/null"

• Loop accessing items('Loop')?['Property'] but source is array of strings

Quick Diagnosis:

// Check your filter: "where": "@contains(item(), 'value')" // ← This means array of STRINGS!

// But loop tries: "value": "@items('Loop')?['PropertyName']" // ← ERROR: Can't access property on string!

Quick Decision:

• ❌ NOT a quick fix → Use automation-debugger skill

• This requires analyzing full data flow and structure

• Quick fix = known patterns; structural bugs = deep debugging

Authentication Errors (401/403)

Pattern Recognition:

• Status: 401 or 403

• Keywords: "unauthorized", "forbidden", "access denied"

Immediate Fix:

{ "actions": { "Scope_With_Auth_Handling": { "type": "Scope", "actions": { "Your_Action": { "type": "ApiConnection", "inputs": { /* your config */ }, "authentication": { "type": "Raw", "value": "@parameters('$connections')['shared_sharepointonline']['connectionId']" } } } }, "Catch_Auth_Error": { "type": "Terminate", "inputs": { "runStatus": "Failed", "runError": { "code": "AuthenticationFailed", "message": "Please re-authenticate the connection in Power Automate" } }, "runAfter": { "Scope_With_Auth_Handling": ["Failed"] } } } }

Instructions:

• Copy the Scope structure above

• Replace "Your_Action" with your failing action

• Update connection name if not SharePoint

• Save and re-authenticate connection in Power Automate UI

Throttling Errors (429)

Pattern Recognition:

• Status: 429

• Keywords: "TooManyRequests", "throttled", "rate limit"

Immediate Fix - SharePoint/OneDrive:

{ "actions": { "Apply_to_each_FIXED": { "type": "Foreach", "foreach": "@body('Get_items')?['value']", "runtimeConfiguration": { "concurrency": { "repetitions": 1 } }, "actions": { "Your_API_Action": { "type": "ApiConnection", "inputs": { /* your config */ }, "runAfter": {} }, "Delay_1_Second": { "type": "Wait", "inputs": { "interval": { "count": 1, "unit": "Second" } }, "runAfter": { "Your_API_Action": ["Succeeded"] } } } } } }

Instructions:

• Find your Apply to each loop

• Add runtimeConfiguration.concurrency.repetitions: 1

• Add Delay action after API calls (1 second for SharePoint, 3 seconds for OneDrive)

• Save and test

Quick calculation:

• SharePoint limit: 600/minute → 1-second delay = 60/minute (safe)

• OneDrive limit: 100/minute → 3-second delay = 20/minute (safe)

Parse JSON Failures

Pattern Recognition:

• Error: "InvalidTemplate", "cannot be evaluated"

• Keywords: "Parse JSON", "dynamic content", "schema"

Immediate Fix:

{ "actions": { "Parse_JSON_FIXED": { "type": "ParseJson", "inputs": { "content": "@body('HTTP')", "schema": { "type": "object", "properties": { "id": {"type": "string"}, "name": {"type": "string"}, "value": {"type": ["string", "null"]} } } } }, "Safe_Access_Property": { "type": "Compose", "inputs": "@coalesce(body('Parse_JSON_FIXED')?['value'], 'default')", "runAfter": { "Parse_JSON_FIXED": ["Succeeded"] } } } }

Instructions:

• Add Parse JSON action with proper schema

• Use ?['property'] for safe navigation (optional chaining)

• Use coalesce() for default values with null properties

• Test with sample payload first

Schema generation tip:

• Copy sample JSON response

• Use "Generate from sample" in Parse JSON action

• Add "null" to type array for optional fields: {"type": ["string", "null"]}

Timeout Errors

Pattern Recognition:

• Error: "timeout", "timed out"

• Context: Large files, long operations, Do until loops

Immediate Fix - Do Until:

{ "actions": { "Do_until_FIXED": { "type": "Until", "expression": "@equals(variables('Complete'), true)", "limit": { "count": 60, "timeout": "PT1H" }, "actions": { "Your_Action": { "type": "Compose", "inputs": "@variables('Data')" }, "Check_Complete": { "type": "SetVariable", "inputs": { "name": "Complete", "value": "@greater(length(variables('Data')), 0)" }, "runAfter": { "Your_Action": ["Succeeded"] } } } } } }

Instructions:

• Always set limit.count and limit.timeout in Do until

• Recommended: count=60, timeout="PT1H" (1 hour)

• Add exit condition that WILL eventually be true

• Test with smaller iterations first

Immediate Fix - Large Files:

{ "actions": { "Check_File_Size_FIXED": { "type": "If", "expression": { "and": [{ "lessOrEquals": [ "@triggerBody()?['Size']", 50000000 ] }] }, "actions": { "Process_Normal_File": { "type": "ApiConnection", "inputs": { /* your file action */ } } }, "else": { "actions": { "Log_Large_File": { "type": "Compose", "inputs": "File over 50MB - skipping" } } } } } }

Instructions:

• Add file size check before processing

• OneDrive: 50MB limit (50000000 bytes)

• SharePoint attachments: 90MB limit (94371840 bytes)

• Alternative: Use different API for large files

Not Found Errors (404)

Pattern Recognition:

• Status: 404

• Keywords: "not found", "does not exist"

Immediate Fix:

{ "actions": { "Try_Get_Item": { "type": "Scope", "actions": { "Get_Item": { "type": "ApiConnection", "inputs": { /* your get action / } } } }, "Handle_Not_Found": { "type": "If", "expression": { "and": [{ "equals": [ "@result('Try_Get_Item')[0]['status']", "Failed" ] }] }, "runAfter": { "Try_Get_Item": ["Failed", "Succeeded"] }, "actions": { "Create_If_Missing": { "type": "ApiConnection", "inputs": { / your create action */ } } }, "else": { "actions": { "Use_Existing": { "type": "Compose", "inputs": "@body('Get_Item')" } } } } } }

Instructions:

• Wrap Get action in Scope

• Check result status with result() function

• Create item if not found (or handle alternative)

• Use dynamic IDs from previous actions (don't hardcode)

Expression Errors

Pattern Recognition:

• Error: "Unable to process template language expressions"

• Keywords: "property doesn't exist", "invalid expression"

Common Quick Fixes:

Missing Property:

// BAD @body('Get_Item')['MissingProperty']

// GOOD @body('Get_Item')?['MissingProperty']

// BETTER (with default) @coalesce(body('Get_Item')?['MissingProperty'], 'default_value')

Type Mismatch:

// BAD - concatenating string and number @concat('Value: ', variables('NumberVariable'))

// GOOD @concat('Value: ', string(variables('NumberVariable')))

Array Access:

// BAD - array might be empty @first(body('Get_Items')?['value'])

// GOOD @if(greater(length(body('Get_Items')?['value']), 0), first(body('Get_Items')?['value']), null)

Null Checks:

// BAD @variables('NullableVar')

// GOOD @if(empty(variables('NullableVar')), 'default', variables('NullableVar'))

Function Parenthesis Placement (NEW!):

// BAD - format parameter outside formatDateTime() toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM')) // ↑ // This closes formatDateTime BEFORE format string!

// ERROR MESSAGE: // "The template language function 'toLower' expects one parameter: // the string to convert to lower casing. The function was invoked with '2' parameters."

// GOOD - format parameter INSIDE formatDateTime() toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM')) // ↑ // Format string is now INSIDE formatDateTime()

Copy-Paste Fix for Filter Query:

// Original (broken): @and( contains(toLower(item()), 'cnesst'), contains( toLower(item()), toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM')) )

// Fixed expression (ready to copy-paste into Filter Query action): @and( contains(toLower(item()), 'cnesst'), contains( toLower(item()), toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM')) ) )

Quick Fix Decision Tree

Error Code/Type │ ├── Data Structure Mismatch (item() vs item()?['Prop']) → ❌ Use automation-debugger (NOT quick fix) │ ├── 401/403 → Re-authenticate connection + Add error handling │ ├── 429 → Set concurrency=1 + Add delays │ ├── 404 → Add existence check + Handle not found case │ ├── Timeout → Add limits to Do until OR check file sizes │ ├── Parse JSON → Add schema + Use safe navigation (?[]) │ └── Expression Errors ├── "Function expects N parameters but was invoked with M" → Check parenthesis placement ├── Missing/null properties → Add ?[] + coalesce() ├── Type mismatch → Add string(), int() conversions └── Array access → Add length checks + first()/last()

When Quick Fix Isn't Enough

Escalate to automation-debugger skill if:

• Quick fix doesn't resolve the error

• Error doesn't match common patterns

• Multiple interrelated errors

• Complex flow logic involved

• Need deep documentation research

• Unclear root cause

Output Format

Quick fixes provide:

• Pattern identification (which common error)

• Immediate fix (JSON snippet for actions/nodes)

• Copy-paste ready expressions (for Filter Query, Condition, Variable, etc.) - ALWAYS include the complete @{...} expression ready to copy directly into Power Automate

• Instructions (how to apply)

• Validation (how to test)

IMPORTANT: For expression errors (Filter Query, Condition, Variable, Compose, etc.), ALWAYS provide:

• ❌ Original (broken): The full broken expression

• ✅ Fixed expression: The complete corrected expression ready to copy-paste

Example output format:

Quick Fix: Function Parenthesis Placement Error

Pattern: formatDateTime() format parameter placed outside function call

Original (broken): @and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date']),'yyyy-MM')))

Fixed expression (copy-paste ready): @and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))))

What changed: Moved 'yyyy-MM' format string INSIDE formatDateTime() parentheses

No need for full debug report structure - focus on speed and copy-paste ready fixes.

Best Practices

• Test first: Apply quick fix to copy of flow

• Verify limits: Confirm connector-specific constraints

• Monitor: Check flow run history after fix

• Escalate if needed: Use automation-debugger for persistent issues

Common Connector Limits (Quick Reference)

Connector API Limit Recommended Delay

SharePoint 600/60s 1 second

OneDrive 100/60s 3 seconds

HTTP 600/60s 1 second

Apply to each 50 concurrent Set to 1 for APIs

Examples

User: "I'm getting throttled in SharePoint, need quick fix"

Output:

Quick Fix: SharePoint Throttling (429)

Reduce concurrency and add delays:

[JSON snippet with concurrency + delay]

Apply these changes:

1. Set concurrency to 1
2. Add 1-second delay
3. Save and test

This limits you to 60 API calls/minute (well under 600/minute limit).

User: "Parse JSON failing with 'property doesn't exist'"

Output:

Quick Fix: Parse JSON Property Access

Use safe navigation (?[]) and defaults:

[JSON snippet with coalesce()]

Changes needed:

1. Replace ['property'] with ?['property']
2. Add coalesce() for defaults
3. Test with sample data

This handles null/missing properties gracefully.

User: "Getting error 'toLower expects one parameter but was invoked with 2 parameters' in my Filter Query"

Output:

Quick Fix: Function Parenthesis Placement Error

Pattern: formatDateTime() format parameter placed outside function call

Original (broken): @and( contains(toLower(item()), 'cnesst'), contains( toLower(item()), toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM')) )

Fixed expression (copy-paste ready): @and( contains(toLower(item()), 'cnesst'), contains( toLower(item()), toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM')) ) )

What changed:

1. Moved 'yyyy-MM' format string INSIDE formatDateTime() parentheses (before the closing parenthesis)
2. The format parameter is now the second parameter of formatDateTime(), not a second parameter to toLower()

How to apply:

1. Open your Filter Query action in Power Automate
2. Delete the current expression
3. Paste the fixed expression above
4. Save and test with your data

Integration with Other Skills

• Quick fix succeeds → Done!

• Quick fix fails → Automatically suggest automation-debugger

• Unknown error → Immediately defer to automation-debugger

This skill optimizes for speed on common patterns while maintaining quality through specialized skill delegation when needed.

Version: 1.2 Last Updated: 2025-10-31

Changelog

Version 1.2 (2025-10-31)

Major Enhancements:

• ✅ Added Function Parenthesis Placement Error pattern to Expression Errors

• ✅ Enhanced Output Format to emphasize copy-paste ready expressions for all expression types

• ✅ Updated Activation Triggers to include expression error patterns

• ✅ Expanded Decision Tree with detailed expression error breakdown

• ✅ Added complete example showing function parenthesis error fix

Key Additions:

• Function parameter placement detection (e.g., toLower(formatDateTime(...), 'format') → error)

• Copy-paste ready expression format with ❌ broken / ✅ fixed sections

• Direct support for Filter Query, Condition, Variable, Compose expression fixes

• Clear before/after comparison showing exactly what changed

New Triggers:

• "Function expects one parameter but was invoked with 2"

• "Unable to process template language expressions"

• "Fix this expression/filter/query/condition"

• User provides code snippet and asks for "quick fix"

Output Philosophy:

• Always provide complete, ready-to-paste expressions

• Show original (broken) and fixed versions side-by-side

• Explain exactly what changed and why

• Include step-by-step application instructions

Version 1.1 (2025-10-31)

Minor Improvements:

• ✅ Added Data Structure Check section - Quick validation before applying fixes

• ✅ Added Data Structure Mismatch pattern - Recognizes when NOT to quick fix

• ✅ Updated Decision Tree - Now includes structural bug detection

• ✅ Clarified escalation to automation-debugger for structural issues

Key Additions:

• Quick data type check: item() vs item()?['Property'] indicator

• Clear guidance on when quick fix is inappropriate

• Structural bugs (string vs object mismatch) → Use automation-debugger

Philosophy:

• Quick fixes are for known, simple patterns

• Data structure bugs require deep analysis → Not quick fix territory

• Fast triage: Recognize when to escalate immediately