Claude Prompts for Power Automate

<context>Our approval policy, verbatim: [PASTE THE POLICY: thresholds, approver roles, sequence, what happens on rejection]. The request arrives via [FORM / SHAREPOINT LIST / EMAIL].</context> <task>Turn the policy into a flow design. Specify each approval stage, the approval type, what happens on approve and on reject at every stage, and where the record is written.</task> <format>1. Stage table: stage, approver source, approval type (first to respond, everyone must approve, custom responses), timeout 2. Approve path and reject path per stage 3. Data written back at each transition, with the field names 4. Where a Condition is needed versus a Switch 5. Policy gaps you found, phrased as questions for the process owner</format>

<context>Routing rules: [PASTE THE AMOUNT BANDS AND WHO APPROVES EACH]. Requester attributes available in the flow: [LIST FIELDS: amount, department, cost center, requester email]. Approver directory lives in: [SHAREPOINT LIST / AZURE AD / HARDCODED].</context> <task>Write the routing logic. Give me a Switch or nested Condition structure plus the expression that resolves the approver email dynamically instead of hardcoding names.</task> <format>1. Recommended structure: Switch, nested Conditions, or a lookup table, with the reason 2. Expression that resolves the approver email, in a code block 3. OData filter query for the approver lookup, if a list is used 4. Fallback when no approver matches, so the flow never sends to an empty address 5. How to change bands later without editing the flow</format>

<context>I want the approval to happen inside Teams with an adaptive card. Data available at that point in the flow: [LIST THE FIELDS AND SAMPLE VALUES]. Actions the approver needs: [APPROVE / REJECT / REQUEST INFO / OTHER].</context> <task>Write the complete Adaptive Card JSON for the Post adaptive card and wait for a response action, using dynamic content placeholders where my flow data goes.</task> <format>1. Full card JSON in a code block, schema version 1.4 or lower 2. Table of every placeholder in the JSON and which flow field replaces it 3. Which action outputs to read for the response, and the expression to read the chosen action 4. How the card should render after a response 5. Two rendering pitfalls on mobile Teams to check before shipping</format>

<context>Approvals stall. SLA: [HOURS OR DAYS] to first response, then escalate to [ROLE]. Business hours: [HOURS AND TIME ZONE]. Current flow after the approval action: [DESCRIBE].</context> <task>Design the reminder and escalation pattern, including the expression that computes the SLA deadline in business hours and the loop structure that chases without spamming.</task> <format>1. Structure: parallel branch, Do Until, or Delay Until, with the recommendation and why 2. Expression computing the deadline, in a code block 3. Reminder cadence and the exact wording of reminder one and reminder two 4. Escalation trigger point and who gets notified 5. How to stop the reminder loop the moment the approval lands 6. Flow run duration limits that could bite on long SLAs</format>

<context>Approvers say the request emails are unreadable. Fields I can include: [LIST THEM WITH SAMPLE VALUES]. The approver needs to decide from the email alone, without opening the source system.</context> <task>Write the HTML body for the Send an email (V2) action: a summary block, a details table, and the decision links, using placeholders for my dynamic content.</task> <format>1. Complete HTML in a code block, inline CSS only 2. Placeholder table: token in the HTML, flow field that replaces it 3. Subject line pattern that stays scannable in a phone notification 4. Which fields to show above the fold and which to push to the table 5. Two Outlook rendering constraints this HTML respects</format>

<context>Approvals stall when the approver is away. What we have: [DESCRIBE ANY DELEGATION LIST, OOF CALENDAR, OR NOTHING]. Approver directory: [WHERE IT LIVES]. Compliance requirement: [WHO MAY DELEGATE TO WHOM, IF ANY].</context> <task>Design delegation handling: how the flow decides the approver is unavailable, who it routes to instead, and how the audit trail records that a delegate acted.</task> <format>1. Availability signal options ranked by reliability, with the caveat on each 2. Delegation table schema: columns, types, sample rows 3. Lookup expression and OData filter query to resolve the active delegate, in code blocks 4. Audit fields written when a delegate approves 5. Guard against a delegation chain looping back to the original approver</format>

<context>We need every approval decision logged for audit. Systems in play: [LIST]. Retention requirement: [DURATION]. Fields currently captured: [LIST OR NONE].</context> <task>Design the audit log table and give me the Compose expressions that populate each field from the approval action outputs.</task> <format>1. Column schema: name, type, required, example value 2. Expression per column pulling from the approval outputs, in code blocks 3. Where in the flow each write happens 4. What to capture on timeout and on flow failure, not just on approve and reject 5. Retention and archival approach for the stated duration 6. Three questions an auditor will ask that this schema answers</format>

<context>Here is a real response from the API I am calling, with values anonymized: [PASTE THE FULL JSON]. Some fields are sometimes null or missing entirely: [LIST THEM, OR SAY NOT SURE].</context> <task>Generate the schema for the Parse JSON action, hardened so a null value does not break the run, and tell me which dynamic content tokens I will get afterwards.</task> <format>1. Complete schema JSON in a code block, ready to paste into Parse JSON 2. Nullable handling: which types you widened and why 3. Table of the dynamic content tokens this schema exposes, with the path for each 4. Expression to reach a nested value without Parse JSON, as a fallback 5. What to do when the API adds a field later</format>

<context>API documentation extract: [PASTE THE ENDPOINT, METHOD, AUTH SCHEME, REQUIRED HEADERS, AND BODY EXAMPLE]. What I need the call to do: [DESCRIBE]. Auth material I hold: [API KEY / OAUTH CLIENT / BEARER TOKEN].</context> <task>Fill in the HTTP action for me: method, URI with encoded parameters, headers, and body, then tell me how to store the secret so it is not sitting in plain text inside the flow.</task> <format>1. Method and full URI, with query parameters shown separately 2. Headers table: key, value, and where the value comes from 3. Request body JSON in a code block 4. Secret storage options ranked: environment variable, Azure Key Vault, connection reference 5. Expected success response shape and the status codes to expect on failure 6. How to test the call before wiring it into the flow</format>

<context>Source schema: [PASTE COLUMN NAMES, TYPES, AND SAMPLE VALUES]. Destination schema: [PASTE THE SAME]. Direction: [ONE WAY / TWO WAY]. Fields that must never be overwritten: [LIST].</context> <task>Build the field mapping and write the transformation expression for every field where the types or formats do not line up.</task> <format>1. Mapping table: source field, destination field, transform needed, expression 2. Unmapped source fields and unmapped destination fields, each with a recommendation 3. Type mismatch list: choice to text, date to string, lookup to id, with the expression for each 4. Fields to skip on update to protect the do-not-overwrite list 5. Three rows of worked example data going through the mapping</format>

<context>My sync creates duplicates when it reruns. Records look like: [PASTE A SAMPLE RECORD WITH FIELD NAMES]. Destination: [SHAREPOINT LIST / DATAVERSE TABLE / SQL]. Fields that together identify a record uniquely: [LIST, OR SAY NOT SURE].</context> <task>Define the dedupe key, write the OData filter query that checks for an existing record, and give me the upsert branch structure.</task> <format>1. Recommended dedupe key and why those fields 2. Expression building the key value, in a code block 3. OData filter query string for Get items, in a code block, with special characters escaped 4. Condition expression that decides create versus update 5. Which destination column must be indexed for this filter to work at volume 6. How to clean up the duplicates already in there</format>

<context>A file lands in [SHAREPOINT LIBRARY / ONEDRIVE / EMAIL ATTACHMENT] on a [FREQUENCY] basis. Header row and two sample rows: [PASTE THEM]. Typical size: [NUMBER OF ROWS]. Destination: [WHERE THE ROWS SHOULD GO].</context> <task>Design the ingestion flow. Cover how the rows get parsed, how bad rows are handled, and how the flow behaves when the same file arrives twice.</task> <format>1. Parsing approach recommendation: Excel connector table, split expressions, or Office Scripts, with the trade-off on each 2. If split is used, the expressions that produce the row array and the field array, in code blocks 3. Row validation rules derived from my sample, and what happens to a row that fails 4. Reprocessing behavior when the same filename arrives again 5. Volume ceiling of this design and what to change above it 6. Where to write the rejected rows so someone can fix them</format>

<context>The sync processes about [NUMBER] records per run and keeps hitting throttling or timing out. Connectors used: [LIST]. Current structure: [DESCRIBE THE LOOP AND WHAT HAPPENS INSIDE IT]. Run duration today: [TIME].</context> <task>Rework it for volume. Cover pagination, loop concurrency, batching, and where a delay is genuinely needed rather than cargo cult.</task> <format>1. Where the current design breaks, action by action 2. Pagination settings to turn on and the threshold to set 3. Concurrency recommendation per loop, with the number and the reason 4. Batching approach and the expression that chunks the array, in a code block 5. Retry policy settings per action: type, count, interval 6. Expected run time after the changes, with the assumption behind the estimate</format>

<context>Today the flow reads every record every run: [DESCRIBE THE CURRENT APPROACH AND THE RECORD COUNT]. Source system: [NAME]. Available timestamp or version fields: [LIST, OR SAY NOT SURE]. Deletions in the source: [HARD DELETE / SOFT DELETE / NEVER].</context> <task>Convert it to a delta sync. Tell me what watermark to store, where to store it, and how to handle records deleted at the source.</task> <format>1. Watermark field choice and why, with the risk if the source clock drifts 2. Storage options for the watermark, ranked, with the failure mode of each 3. OData filter query using the watermark, in a code block 4. Expression that updates the watermark only after a successful run, in a code block 5. Deletion handling strategy for my case 6. Recovery plan for a missed window, so nothing is silently skipped</format>

<context>I need an expression that does this: [DESCRIBE THE LOGIC IN PLAIN ENGLISH]. The input comes from [ACTION NAME AND FIELD], and a sample value looks like: [PASTE ONE]. Expected output: [DESCRIBE OR SHOW].</context> <task>Write the Power Automate expression. This is Workflow Definition Language, not Excel and not JavaScript, so use only functions the designer accepts.</task> <format>1. The expression in a code block, one line, ready to paste 2. Broken into parts, one line of explanation per function used 3. What it returns for my sample value 4. Two edge cases where it returns something unexpected 5. A simpler alternative if my logic can be restructured to avoid nesting</format>

<context>Time zone of the users: [ZONE]. Time zone the data arrives in: [ZONE OR UTC]. I need: [LIST WHAT YOU NEED, for example due date three business days out, month end, age of a record in hours, formatted display date].</context> <task>Give me a pack of ready expressions for each item, with the display format spelled out and daylight saving handled.</task> <format>1. One code block per requirement, each labelled 2. Format string used and what it renders, for each display expression 3. Windows time zone id to use in convertTimeZone, exact string 4. Daylight saving trap that applies to my zones 5. Which of these belong in a Compose action rather than inline, and why</format>

<context>This expression fails when a field is empty or missing: [PASTE THE EXPRESSION]. Error message: [PASTE IT]. The data sometimes looks like: [PASTE A RECORD WITH THE FIELD PRESENT AND ONE WITHOUT IT].</context> <task>Rewrite it so a missing property or a null value returns a sensible default instead of failing the run.</task> <format>1. Why the original fails, in one sentence 2. Null-safe rewrite in a code block 3. Which technique you used: coalesce, empty, the question mark accessor, or a Condition, and when each is right 4. Default value choice and its downstream impact 5. Everywhere else in a flow this same pattern usually needs applying</format>

<context>Source: [SHAREPOINT LIST / DATAVERSE TABLE] named [NAME]. Columns with their internal names and types: [PASTE THEM]. I want to retrieve only records where: [DESCRIBE THE CRITERIA IN PLAIN ENGLISH].</context> <task>Write the Filter Query string for the Get items or List rows action, using internal column names, correct literal syntax per type, and dynamic values where my flow supplies them.</task> <format>1. Filter Query string in a code block, ready to paste 2. Column by column: internal name used, type, literal syntax rule applied 3. Dynamic parts shown as expressions, in code blocks 4. Operators this source does not support, and the workaround for each 5. Indexing requirement to make this query survive a large list 6. How to test the query fast without running the whole flow</format>

<context>My flow has [NUMBER] nested Condition actions and it has become unreadable. Here is the logic: [PASTE THE CONDITION TREE OR DESCRIBE EACH BRANCH AND ITS OUTCOME].</context> <task>Collapse it. Show me which branches merge into a single expression, which belong in a Switch, and which must stay as separate Conditions because they gate different actions.</task> <format>1. Truth table of the current logic, so we agree on what it does 2. Redundant or unreachable branches you found 3. Collapsed expression in a code block for the branches that merge 4. Switch structure for the branches that fit one, with the case values 5. Conditions that must stay separate, and why 6. Before and after action count</format>

<context>I need to pull values out of text. Sample inputs, three of them showing the variation: [PASTE THEM]. What I need extracted: [DESCRIBE EACH VALUE]. The format is [ALWAYS CONSISTENT / SOMETIMES VARIES, describe how].</context> <task>Write the extraction expression for each value using split, substring, indexOf, replace, and the array functions, and make each one fail gracefully when the pattern is absent.</task> <format>1. One labelled code block per extracted value 2. What each returns for all three of my samples 3. Guard clause added for the case where the marker is missing 4. Ranking of which extractions are fragile and why 5. When to stop and use Parse JSON or an AI Builder action instead of string surgery</format>

<context>I have an array in the flow that looks like this: [PASTE THE JSON ARRAY, THREE ITEMS IS ENOUGH]. What I need: [DESCRIBE, for example keep only rows over 1000, reshape to two fields, sum a column, count by category, find the max].</context> <task>Give me the expressions and the Data Operations actions that do this without an Apply to each loop.</task> <format>1. Recommended approach per requirement: Filter array, Select, or a pure expression 2. Code block for each, showing the exact configuration or expression 3. Sum, count, and max expressions using the array functions rather than a loop and a variable 4. Result each one returns on my sample array 5. Action count saved compared with an Apply to each loop 6. Where this approach stops scaling and a loop becomes unavoidable</format>

<context>A run failed. Here are the raw inputs of the failing action: [PASTE THE JSON]. Here are the raw outputs including the error: [PASTE THE JSON]. What the action is supposed to do: [DESCRIBE]. It worked until: [WHEN, OR SAY IT NEVER WORKED].</context> <task>Diagnose the root cause from the payloads, not from guesswork, and give me the specific fix.</task> <format>1. Root cause in one sentence 2. The exact evidence in the JSON that proves it 3. Fix, with the corrected expression or configuration in a code block 4. Why it worked before and stopped, if that applies 5. Guard to add so this failure mode becomes visible instead of silent 6. Two other actions in a typical flow that would break the same way</format>

<context>Flow purpose: [DESCRIBE]. Actions in order: [PASTE THE LIST]. What must happen when a step fails: [NOTIFY WHO / ROLL BACK WHAT / LOG WHERE]. Currently there is no error handling at all.</context> <task>Restructure it into Try, Catch, and Finally scopes, set the run-after configuration on each, and write the expression that produces a readable error summary in the Catch block.</task> <format>1. Which actions go in which scope 2. Run-after settings per scope: has failed, is skipped, has timed out, exactly which boxes to tick 3. Error summary expression using result(), in a code block 4. What the Catch block sends and to whom, with the message text 5. What belongs in Finally versus Catch 6. How to make the run still show as Failed in history after the Catch handles it, if that is what I want</format>

<context>Actions in the flow and what each one writes: [PASTE THE LIST]. Failures we see: [DESCRIBE: transient timeouts, 429s, 500s, or something else]. Records get created twice when we retry: [YES / NO / NOT SURE].</context> <task>Set the retry policy per action and tell me which actions are unsafe to retry as built, with the change that makes them idempotent.</task> <format>1. Table: action, recommended retry policy, count, interval, reason 2. Actions that must have retry turned off, and why 3. Idempotency fix per unsafe action, with the check expression or filter query in a code block 4. Which HTTP status codes are worth retrying and which are permanent 5. Total worst-case run duration once retries are set 6. How to tell from run history whether a retry saved you or hid a real bug</format>

<context>Nobody notices when this flow fails until a user complains. Flow name: [NAME]. Who should be alerted: [PERSON OR CHANNEL]. What they need to know to act: [DESCRIBE]. Alert channel: [EMAIL / TEAMS].</context> <task>Design the failure alert. Include the expression that builds a clickable link to the exact failed run, so the recipient lands on the run history instead of hunting for it.</task> <format>1. Expression that assembles the run URL from workflow() and the run name, in a code block 2. Alert subject line pattern that is scannable in a notification 3. Body content: what to include, what to leave out 4. Where in the flow the alert action goes and its run-after settings 5. How to avoid alert storms when the flow fails 200 times in an hour 6. Escalation rule if nobody acknowledges</format>

<context>The designer refuses to save, or the run fails with this error: [PASTE THE FULL ERROR TEXT]. The expression involved: [PASTE IT]. What I was trying to do: [DESCRIBE].</context> <task>Decode the error into plain English and give me the corrected expression.</task> <format>1. What the error actually means, stripped of Microsoft phrasing 2. The specific character, function, or type that violates the rule 3. Corrected expression in a code block 4. Rule of Workflow Definition Language I broke, stated once so I recognize it next time 5. Fast way to isolate this class of error using a Compose action 6. Two similar error strings and what they mean, since they often travel together</format>

<context>Here is the flow definition JSON, exported from the solution: [PASTE IT]. Nobody currently understands this flow: [SAY WHO BUILT IT AND WHETHER THEY ARE STILL HERE].</context> <task>Read the definition and write documentation a new team member could act on: what triggers it, what it does, what it touches, and where it is fragile.</task> <format>1. One-paragraph plain English summary 2. Trigger and its conditions, decoded 3. Numbered walkthrough of the actions with each expression translated to English 4. Every external system it reads from or writes to 5. Missing error handling and unguarded assumptions you can see in the definition 6. Runbook: what to check first when it fails, and who to call</format>

<context>Flow about to go live: [DESCRIBE WHAT IT DOES AND WHAT IT WRITES]. Volume expected: [NUMBER PER DAY]. Blast radius if it misbehaves: [WHO OR WHAT IS AFFECTED]. Test environment available: [YES / NO].</context> <task>Write the test plan. I want the edge cases that break real flows, not the happy path, plus the specific test data to use for each.</task> <format>1. Happy path test, one line 2. Edge case table: case, test data to use, expected behavior, how to verify 3. Cases to cover: empty result set, null field, duplicate trigger, special characters, very large payload, permission denied, connector timeout 4. Concurrency test: what happens when two runs overlap 5. Rollback plan if it misbehaves in production 6. What to watch in run history for the first week and the threshold that means stop</format>