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

javascript

// 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:

javascript

// 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:

json

{
  "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:

json

{
  "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:

json

{
  "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:

json

{
  "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:

json

{
  "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:

json

{
  "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:

javascript

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

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

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

Type Mismatch:

javascript

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

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

Array Access:

javascript

// 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:

javascript

// BAD
@variables('NullableVar')

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

Function Parenthesis Placement (NEW!):

javascript

// 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:

javascript

// 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

automation-quick-fix

NPX Install

Tags

SKILL.md Content

Automation Quick Fix

Supported Platforms

Purpose

Activation Triggers

⚠️ IMPORTANT: Data Structure Check (NEW!)

Quick Data Type Check

Quick Fix Patterns

Data Structure Mismatch (Quick Check - NEW!)

Authentication Errors (401/403)

Throttling Errors (429)

Parse JSON Failures

Timeout Errors

Not Found Errors (404)

Expression Errors

Quick Fix Decision Tree

When Quick Fix Isn't Enough

Output Format

Best Practices

Common Connector Limits (Quick Reference)

Examples

Integration with Other Skills

Changelog

Version 1.2 (2025-10-31)

Version 1.1 (2025-10-31)