Streamlining your tech stack for maximum efficiency

Learn, explore, and grow with our knowledge hub.

Power Automate: Prevent Duplicate Work Items | Smart Statistics

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

Request control desk Illustrative example · reconciliation view
Run attempts 120 Illustrative example
New work items 100 Illustrative example
Existing items found 18 Illustrative example
Unresolved attempts 2 Illustrative example
Attempt outcomes · Illustrative example
Created: 100 of 120 · Illustrative example Recovered: 18 of 120 · Illustrative example Unresolved: 2 of 120 · Illustrative example
  • 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.

Destination column configuration
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

Release evidence to retain
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.

Release-readiness checklist

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.

  1. Microsoft Learn: handle transient faults — retry suitability and repeated side effects.
  2. Microsoft Support: list relationships and unique columns — supported types, indexing and case-insensitive uniqueness.
  3. Microsoft Learn: robust error handling — scopes, run-after rules and retries.

Build automation your team can safely recover.

Smart Statistics helps UK businesses design practical Microsoft 365 workflows with clear ownership, reliable controls and measurable results.