automation-quick-fix

name

automation-quick-fix

description

Fast automation platform error resolver for Power Automate, n8n, Make, Zapier and other platforms. Handles common patterns like 401/403 auth errors, 429 throttling, and data format issues. Provides immediate fixes without deep research for well-known error patterns. Use when error matches common scenarios (status codes 401, 403, 404, 429, timeout, parse JSON failures). For complex or unknown errors, defer to automation-debugger skill. When the user outputs some code/json snippets and ask for a quick fix, this skill will provide immediate solutions.

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)

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