One request reference associated with one confirmed result

A workflow receives a request, creates a project and prepares the welcome message. The connection fails before confirmation arrives and someone presses run again. If the system interprets that attempt as a new request, the client may end up with two open projects and two messages nobody intended to send.

This is a hypothetical scenario, but the question belongs in the preparation of any similar process. When the same request appears again, what stops the business from repeating its effect? The answer requires an understandable business rule and an implementation that respects it across every route into the workflow.

Define what counts as the same request

Start by defining the unit of work that should produce only one result: a registration, the opening of a project or a particular task within a contract. Distinguish that unit from the person requesting it. The same client can have several legitimate requests, while the same request can reach the system more than once.

In the hypothetical example, creating one folder per client may be an insufficient rule. The business might open several projects for the same client and need separate folders. Before looking for a technical solution, clarify whether the folder belongs to the commercial relationship, the contract or each approved project.

This decision also affects the team operating the process. If one person thinks in terms of clients and another thinks in terms of projects, they may classify the same input differently. Write the rule with an example of repetition to prevent and another example of new work that should still be accepted.

A name, an email address or similar wording should not determine that classification alone. They may help locate information, but they do not explain the intention behind the request. Someone might write again about the same matter to correct it, or request a different service using exactly the same contact details.

In business process automation, this definition belongs to the design of the work. The implementer needs to know which effect is authorised and under what conditions a new request exists. Without that understanding, a filter may block valid work or allow the repetition you actually wanted to prevent.

Keep a stable reference across attempts

Each operation needs a reference that stays the same when the same intention is repeated. Create or receive that reference before executing the effect and carry it through the process. If every attempt generates a different identifier, the system loses the connection between them and may interpret a repeated attempt as entirely new work.

The reference connects the incoming request, the internal state and the result created. In the example, it should be possible to find the project opening through the request that authorised it. The record needs to preserve that connection even if confirmation arrives later or someone has to check the destination manually.

Define the scope of the identifier as well. A reference only makes sense within the context where it is unique, such as a particular business, source and operation type. The implementer should prevent requests from different contexts being confused simply because they receive the same number in a local tool or an import.

Do not use personal data as an improvised way to identify every operation. An internal identifier can point to the necessary record without exposing the client's email across several systems. The team can still find the request through appropriate access, while keeping only the information each step needs in its records.

When the process crosses different tools, check that the reference reaches all of them. A field lost in an integration can break the protection even when the starting point is well designed. Useful evidence means being able to follow a specific request to its corresponding result, without relying only on nearby dates or similar names.

Record the state of each relevant effect

An automation with several steps needs to distinguish what it received, what it started, what it completed and what remains unconfirmed. Record the state of each effect that must not be repeated. Knowing that the workflow failed at one step does not establish that earlier steps remained unexecuted or can be restarted without review.

In the example, creating the project, preparing the folder and sending a message are different effects. The folder may exist even if sending the message was not completed. If the team only sees a global error state, it may repeat the entire workflow to fix the last step and recreate work that was already done.

The record should connect each step to the result found at the destination. Keeping the reference of the project created is more informative than a generic success note. When a question arises, the responsible person can open the correct object and check whether it corresponds to the request being handled.

A processing state also needs rules. It should not remain active indefinitely without monitoring, nor automatically become permission to start again after some time has passed. Define how to investigate an execution left pending and which evidence allows the team to continue, close it or refer the case for a decision.

Choose names the team understands and use them consistently. “Received” may only mean that the request entered the system; “completed” should correspond to the agreed completion criterion. This distinction prevents confirmation of delivery between systems being presented as evidence that the business work itself has actually been performed.

Confirm how the destination handles repeated requests

Local protection needs to match the behaviour of the system where the effect takes place. Confirm whether that destination recognises a repeated reference, which conditions it requires and how long protection remains available. Do not assume every tool handles repetition in the same way or that a correctly named field automatically activates this capability.

The term idempotency often appears in this technical conversation. For the business decision, the relevant question is whether repeating the same operation, under defined conditions, avoids creating an additional effect. Ask for an explanation applied to your workflow and a demonstration of the behaviour, rather than accepting the term alone in an implementation proposal.

There is a difference between storing a reference in a note and using it within a mechanism that prevents repetition. The note may help an investigation after two records appear. Protection needs to act before authorising another effect, or recognise the repeated request at the destination according to the rules that service supports.

If the destination does not offer that behaviour, the technical team should explain the limitation and the alternatives. It may be necessary to coordinate executions, confirm state through a query or reserve certain cases for human review. The design should reflect the integration's actual capabilities instead of promising that a label resolves every failure.

Avoid applying one tool's retention period or conditions to every other tool. A late repetition may arrive when protection is no longer available. The policy for preserving records and handling old requests needs to be defined for the complete process, including the limits of the services involved in performing the work.

An identified request can be unexecuted, confirmed or uncertain, requiring a different decision in each case

The same reference allows the existing state to be checked. An uncertain result requires verification; it is not permission to create a new request.

Distinguish a lost response from an unexecuted action

When confirmation is missing, preserve the uncertainty until you can verify what happened. A communication failure may prevent the response arriving without preventing the action at the destination. Before repeating work, look up the result using the existing reference or use the safe retry mechanism provided for that integration, keeping the same intended operation.

In the example, the tool may have created the project and the connection failed immediately afterwards. The local panel shows an error, but that does not demonstrate that the project is absent. Creating a new reference to try again may remove precisely the connection that would let the system recognise work already performed.

Ask for the uncertain state to be visible to whoever monitors the process. “Awaiting confirmation” should mean that a verification is pending, with an owner and a next step. It should not hide errors in a forgotten list or present a conclusion to the client that the business has not yet been able to establish.

Being able to confirm whether an automation stopped when the button returns an error starts from the same need to observe the actual state. Here, the question is whether the effect already happened. The panel's appearance helps guide the investigation, but does not replace confirmation in the relevant system.

If verification is not possible at that moment, define who decides between waiting and intervening. The consequence of repeating a message differs from repeating a project opening or another commitment. The process needs to handle uncertainty according to that consequence, preserving a history of what was observed and decided by the responsible people.

Prevent two executions from proceeding at the same time

Checking whether a request exists and creating the result can compete with another execution. Two attempts may inspect the same state before either changes it. The implementation needs to coordinate this decision within the responsible system, so that both attempts do not receive permission to produce the same effect simply because they arrived together.

Disabling a button while a request is running improves the interaction, but does not cover every entry point. Another window may be open, an automatic attempt may run or another team member may start the operation. The rule has to remain valid when repetition arrives through a route other than the usual interface.

Ask the technical team to explain where that coordination takes place. A visual condition or a spreadsheet search may not protect the interval between checking and acting. What matters is an appropriate mechanism for deciding who can proceed, with a competing attempt finding a coherent state for the same request.

An execution that started and then stopped providing updates also needs handling. Releasing pending work without checking the destination may create the second action that protection was intended to prevent. The recovery procedure must consider the possibility that the first execution produced the effect before losing its confirmation.

You do not need to choose the implementation technique yourself to require this behaviour. Describe the expected result and ask for a test involving simultaneous attempts. The implementer should show what is recorded, which attempt proceeds and how the others receive useful information without carrying out the work again.

Separate repetition, correction and newly authorised work

A legitimate change should not be confused with a repetition of an earlier request. Define how data is corrected, how work is added and when a new operation begins. The same reference with different content requires explicit handling, so the system neither ignores a necessary correction nor silently executes an intention different from the one originally authorised.

In the example, changing the project's display name may be an update to the existing object. Requesting another project for the same client represents new work. Both situations may arrive through the same interface, but they require different decisions and should not depend on the operator guessing how the workflow will interpret them.

An import can also bring revised information about earlier requests. Before running it, clarify whether it is intended to update records or create new ones. If the process does not distinguish those intentions, improved data may be treated as a reason to repeat project openings or other effects that have already happened.

Preserve the relationship between the original operation and the authorised change. The team needs to understand what changed and which result should exist afterwards. This helps resolve disagreements without erasing the history or replacing one reference with another simply to get past a block that nobody has investigated properly.

When repetition is intentional, give it its own decision path. Resending a communication at the client's request differs from trying to recover a lost confirmation. The record should show that intention and its corresponding authorisation, allowing a deliberate exception to be distinguished from duplication caused by the operation of the workflow.

Include manual interventions in the same controls

The team may complete a task manually while the automation remains pending. That work needs to be linked to the same request before the workflow proceeds again. Define how the operator checks state, takes responsibility for the intervention and records the result, so the manual alternative does not cause another execution when the system recovers.

In the example, someone may open the project directly in the tool to avoid delaying the client. If that action exists only in an internal conversation, the automation may still consider the project uncreated. The person needs to connect the manual result to the original reference and make clear that this effect has already occurred.

Avoid parallel procedures where every team maintains its own list of exceptions. A list may provide support, but the state used to decide execution must receive the relevant information. Otherwise there is apparent coordination between people and an automatic rule that continues to operate using incomplete data about work already carried out.

The person responsible for the automation should understand these intervention routes. They do not need to perform every task, but must ensure the team knows where to check, how to mark completed work and who resolves a conflict between the local record and the result found at the destination.

Also confirm how manually handled cases return to the workflow. Some may continue at the next step, while others need to be closed. Resumption should use what has already happened, preserving necessary steps without executing again those that were completed through an authorised alternative to the automatic process.

Test repeated requests before relying on the workflow

Tests should include the same input repeated, simultaneous attempts, lost confirmation and manual intervention before resumption. Use a controlled environment and check the result at the destination as well as the internal state. The acceptance criterion is the correct business effect with an understandable history, rather than merely the absence of an error message.

Prepare the cases with someone who understands the operation. For each one, write down what should exist at the end and which work should remain pending. This preparation makes the test verifiable and prevents the team declaring success simply because the workflow reached its final step during an uninterrupted execution.

Include two legitimate requests from the same client as well. Protection against duplication should preserve both when they represent distinct work. An overly broad filter may look effective because it blocks repetitions, while silently preventing the business from receiving new opportunities or delivering services that were actually requested by the client.

When testing an automation before handing it to the team, observe each integration and the complete journey. For this specific check, add repetition and concurrency conditions. An isolated test of each step does not demonstrate that the whole process preserves the reference and state when confirmation is lost somewhere along the way.

Keep the expected and observed results, including unresolved limitations. If an integration does not allow a particular effect to be verified, that restriction needs to be part of the delivery decision. The aim is to know when the team can operate confidently and when it should interrupt automatic execution to confirm the result.

Finish delivery with a rule the team can apply

Before putting the automation into service, confirm the request definition, the reference used, the states and the handling of uncertain results. Identify who monitors exceptions and how manual actions are recorded. Delivery becomes stronger when the team can explain what happens to a repeated request and demonstrate that behaviour in a controlled test case.

Start with the effect whose repetition would have the greatest consequence in the process you are building. Follow a request from entry to destination and check every point where its reference or state might be lost. That observation helps uncover concrete gaps without turning the review into a vague discussion about the reliability of all technology.

Then document the decision briefly and connect it to how the process actually works. Operators should know when they may repeat an attempt, when they need to check the destination and when to ask for help. The document needs to follow integration changes, because protection that worked in one version may depend on conditions that have since changed.

I want an automation to remove repetitive work from the team without multiplying the effects of an uncertain attempt. That requires treating repetition as part of process design. A stable reference, verifiable state and recovery criteria help make the distinction, keeping visible what is confirmed and what still requires a decision.