Smart Statistics · Practical automation
Stop Duplicate Work:
Build a Replay-Safe Power Automate Request Flow
A repeat run should find the same work item. Build that protection into a SharePoint destination, then make uncertain outcomes visible.
28 October 2026 · Power Automate + SharePoint · UK business tutorial
- Requests list · durable source ID
- WorkQueue · unique destination key
- Recovery · verify existing item
- Exception review · named owner
When a retry becomes a second job
A facilities request is submitted once, but an administrator resubmits its failed flow run. If the first run created the work item before losing its response, a second unprotected create can leave two teams acting on the same request.
Microsoft recommends assessing whether an operation is safe to retry and warns that repeating non-idempotent steps can cause inconsistencies or duplicate messages [1]. Here, “replay-safe” means that repeating one source request produces at most one destination work item for the same key.
Scope: this tutorial protects creation of a SharePoint work-queue record. It does not guarantee exactly-once emails, approvals, payments or downstream actions. It also does not detect two separately entered requests describing the same real-world problem.
Choose the smallest safe boundary
A good fit
An internal request list creates one work item per request. The source item ID is stable and the destination can enforce uniqueness.
A weak shortcut
“Get items, then create if empty” can race: two runs may both see no item. A preliminary lookup is an optimisation, not the protection.
A different design
Multi-system transactions need destination-specific idempotency and recovery. Do not extend this list pattern into a claim of transactional guarantees.
Build the flow in a test site first
You need permission to create lists and flows, an authorised SharePoint connection, and a test request. Confirm connector availability, licensing and data policies in your tenant. This recipe uses SharePoint and built-in cloud-flow actions.
Create Requests and WorkQueue
In Requests, keep Title required. In WorkQueue, create these columns with the names below so their internal names remain predictable.
| Column | Type and rule | Purpose |
|---|---|---|
| RequestKey | Single line of text; required; enforce unique values | Stops a second item with the same operation key |
| SourceItemID | Number; zero decimals; required | Checks the source identity |
| SourceListKey | Single line of text; required | Identifies the source list |
| Title | Single line of text; required | Initial request description |
| WorkStatus | Choice: New, In progress, Closed | Business work status, separate from flow outcome |
SharePoint supports unique single-line text columns; uniqueness is case-insensitive and requires an index [2]. Enable the constraint before testing. Restrict deletion and key editing to authorised maintainers; hiding a field on a form is not security.
Build a stable operation key
Create an automated cloud flow with SharePoint’s When an item is created trigger pointing to Requests. Add a Compose action named RequestKey. Replace the example list GUID with the actual Requests list GUID, retaining a consistent lower-case representation.
concat(
'requests-11111111-2222-3333-4444-555555555555:',
string(triggerBody()?['ID']),
':create-work-item'
)
The same source item and operation must always produce the same key.
Do not include utcNow(), the flow run ID or a deployment
version. A routine release must not accidentally create a new business
operation. Never reuse this namespace for a replacement source list.
Attempt the write directly
Add a Scope named AttemptCreate. Inside, add SharePoint
Create item targeting WorkQueue. Map RequestKey to
outputs('RequestKey'), SourceItemID to the trigger ID,
SourceListKey to the same source-list GUID, Title to the trigger Title,
and WorkStatus to New.
Keep unrelated side effects out of this scope. The destination uniqueness rule protects overlapping create attempts. Review the action’s retry settings in your environment; even a retry after a committed write can return a duplicate error, so recovery remains necessary.
Resolve failure and timeout by checking the destination
Add a Scope named RecoverCreate. Configure its Run after on AttemptCreate for has failed and has timed out. Run-after rules and scopes support outcome-specific error handling [3].
Inside RecoverCreate, add Get items on WorkQueue, named FindExisting. Set Top Count to 2 and enter this expression in Filter Query. The key is composed only of controlled text, a GUID and an integer, so it contains no user-supplied quote characters.
concat(
'RequestKey eq ',
decodeUriComponent('%27'),
outputs('RequestKey'),
decodeUriComponent('%27')
)
Then use a Condition:
equals(length(body('FindExisting')?['value']), 1)
In the Yes branch only, read
first(body('FindExisting')?['value']).
Verify its SourceItemID and SourceListKey match the expected source.
Record its destination ID and a “Recovered existing item” outcome.
Do not overwrite its Title or WorkStatus: someone may already be working on it.
If the lookup returns no item, multiple items, a mismatched source or an error, leave the request unresolved and terminate as Failed. A permission error is not evidence of a duplicate. Do not use a catch-all “Succeeded” termination. If a just-committed item is temporarily unavailable, investigate or retry recovery later using the same key.
Keep operational evidence separate
Create an append-only AttemptLog list with RequestKey, RunID, Outcome, DestinationID, OccurredUTC and ErrorSummary. Log Created after a successful create, Recovered after verified lookup, and Unresolved where logging remains available. Multiple attempt records for one key are intentional.
workflow()?['run']?['name']
utcNow()
These expressions supply the run identifier and log timestamp; they do not belong in RequestKey. If SharePoint is unavailable, logging there may fail too. Retain a monitored failed-run path and a documented support route. Do not let a failed logging step trigger another business create outside the protected operation.
Best practice · recover evidence, not assumptions
A green run is not the acceptance test
Test the committed-but-unconfirmed case
Pre-create a matching destination item in the test list, then run the request again. The create should fail on uniqueness and recovery should identify that item. Separately test recovery failure so an unavailable lookup cannot masquerade as success.
Keep retries inside the safe boundary
A safe work-item create does not make a later email safe. Track and reconcile each consequential side effect separately. Never replay an entire multi-step business process merely because its final notification failed.
Prove the behaviour before rollout
| Test | Expected result |
|---|---|
| New source request | One destination record; Created outcome |
| Resubmit the same run | Same destination ID; Recovered outcome |
| Two simultaneous attempts | At most one destination item for that key; recovery or visible unresolved outcome for the other attempt |
| Matching item already exists | Recovery verifies source fields without resetting business status |
| Connection cannot read or write | Visible failure; no assumption that a duplicate exists |
| Different source item | Different key and a separate work item |
Stop release if duplicate keys can be inserted, failed lookups appear successful, or the support owner cannot trace a request to its destination. Trigger concurrency settings are not a replacement for destination protection.
Make safe recovery part of everyday work
The process owner defines what counts as the same request and authorises corrections. The flow maintainer owns key stability, connection health and release tests. A named support owner reviews unresolved attempts and aged source requests with no destination.
Start with one team. Teach users to quote the source request ID, inspect the existing work item and avoid “fixing” failures by creating new source records. Preserve keys for the agreed replay horizon; deleting protected items removes the protection against later replays.
Measure duplicate destination keys, unresolved request age, time to verified recovery and manual rework minutes. Reconcile distinct source keys against destination keys: a count of successful runs alone misses both lost work and harmless replays. Any projected time saving should use your measured baseline, not the illustrative dashboard above.
Frequently asked questions
Does setting concurrency to one prevent duplicates?
It can reduce overlapping runs in one flow, but it does not identify a replay or protect against another writer. Enforce the business key at the destination.
Does this guarantee exactly-once email delivery?
No. The tutorial protects one SharePoint work-item creation. Email, approvals and external transactions need their own duplicate-handling and recovery design.
Should I delete a work item to replay a request?
No. Retain its unique key and evidence. Investigate the existing record and use an authorised correction process rather than removing the duplicate protection.
What if the same request is entered twice?
Two new source items have different IDs, so this design treats them as different requests. Prevent business duplicates at intake using a stable external reference where one exists.
Sources and implementation boundaries
Microsoft documentation checked on 28 October 2026. The implementation pattern is Smart Statistics guidance; the dashboard is invented. Validate the expressions, action names, permissions and recovery paths in your tenant before production use.
- Microsoft Learn: handle transient faults — retry suitability and repeated side effects.
- Microsoft Support: list relationships and unique columns — supported types, indexing and case-insensitive uniqueness.
- Microsoft Learn: robust error handling — scopes, run-after rules and retries.