Automation Quick Fix

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:

1. Copy the Scope structure above
2. Replace "Your_Action" with your failing action
3. Update connection name if not SharePoint
4. 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:

1. Find your Apply to each loop
2. Add runtimeConfiguration.concurrency.repetitions: 1
3. Add Delay action after API calls (1 second for SharePoint, 3 seconds for OneDrive)
4. 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:

1. Add Parse JSON action with proper schema
2. Use ?['property'] for safe navigation (optional chaining)
3. Use coalesce() for default values with null properties
4. 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:

1. Always set limit.count and limit.timeout in Do until
2. Recommended: count=60, timeout="PT1H" (1 hour)
3. Add exit condition that WILL eventually be true
4. 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:

1. Add file size check before processing
2. OneDrive: 50MB limit (50000000 bytes)
3. SharePoint attachments: 90MB limit (94371840 bytes)
4. 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:

1. Wrap Get action in Scope
2. Check result status with result() function
3. Create item if not found (or handle alternative)
4. 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:

1. Pattern identification (which common error)
2. Immediate fix (JSON snippet for actions/nodes)
3. Copy-paste ready expressions (for Filter Query, Condition, Variable, etc.) - ALWAYS include the complete @{...} expression ready to copy directly into Power Automate
4. Instructions (how to apply)
5. 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

1. Test first: Apply quick fix to copy of flow
2. Verify limits: Confirm connector-specific constraints
3. Monitor: Check flow run history after fix
4. Escalate if needed: Use automation-debugger for persistent issues

Common Connector Limits (Quick Reference)

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