1. LandOffer
  2. Blog
  3. All articles
  4. RPA Developer Portfolio: Demonstrate Exceptions, Retries, and Human Handoff

Job search

RPA Developer Portfolio: Demonstrate Exceptions, Retries, and Human Handoff

Build a reviewable RPA portfolio with actual local exception traces, bounded retries, duplicate protection, and a complete pending handoff.

9 min readLandOffer team

A successful RPA recording shows that one input reached its destination. An employer also needs to see what happens when the input is incomplete, the destination stops responding, or the write succeeds but its confirmation disappears. Those cases reveal whether your automation protects the process while someone investigates.

An RPA developer portfolio can make that reasoning reviewable with a small synthetic queue, a bounded recovery policy, and a handoff packet that preserves the last known state. The example below was actually executed as an original Python simulation. It did not run UiPath, operate a business application, send a notification, or involve a person accepting a task.

A classic illustrated workshop sorts incomplete tasks, bounded retries, and single stamped receipts.

Use LandOffer’s recently posted jobs to find the exception handling or recovery responsibility your sample should explain. Match the evidence to that responsibility before expanding the mock.

Define the transaction before adding retries

Choose a harmless process whose result can be counted. Here, a fictional catalog receives a product name and category, then creates a local record. Success requires a receipt whose stored digest matches the expected input. A script reaching its final line would not, by itself, establish that the intended record exists.

The owned fixture contains no customer data, credentials, or external destination. Its store is an in-memory Python dictionary. Each task carries an idempotency key and a SHA-256 digest of its payload. The store creates a receipt on the first matching insert, returns the existing receipt for the same key and payload, and refuses reuse of that key with different data.

Give the reviewer the inputs, commit decision, receipt, and write count together. These let them connect a recovery claim to the destination state the mock actually recorded. It does not prove durable recovery after a process crash, safe concurrent execution, or atomic behavior across two systems. Those remain implementation requirements for a real deployment.

Write the process contract in ordinary language before showing a flow diagram: “Create one catalog record for an unchanged request, stop on invalid business data, and hold unresolved technical failures for review.” The word “one” is a constraint to verify, not an assurance supplied by a retry component.

Classify failures by what could change

UiPath's current Orchestrator exception guidance distinguishes technical application failures from invalid or missing business data. Its documented queue retry behavior depends on exception classification and configuration; business exceptions are not retried by default. That distinction informs this demonstration, but the Python labels are an authored policy rather than exported Orchestrator statuses.

For a missing category, another identical attempt cannot supply the absent value. Hold the item with the missing-field reason, so a reviewer can request the category instead of investigating repeated technical failures. A temporarily unavailable destination may recover, so a limited retry can be reasonable when repeating the operation is safe. A lost acknowledgement requires another question: did the destination already commit the write?

Avoid treating every timeout as proof of failure. A client can lose its response after the destination has changed. Retrying the entire transaction without reconciliation can duplicate a record. A useful portfolio explains where the fault was injected and what evidence establishes the commit state inside the demonstration.

A platform feature is also narrower than a process policy. The current Retry Scope documentation describes repeating contained activities when a condition is unmet or an error occurs, with retry-count and interval settings. It also documents workflow-context restrictions. Do not assume a generic retry wrapper automatically classifies business failures, protects writes, or persists a handoff.

Asset one: a completed queue and recovery trace

The first deliverable is a completed six-delivery ledger, backed by the original script and two fresh executions. All names and products are fictional. The simulation permits at most three total attempts per delivery: the initial attempt plus up to two retries. Its virtual backoff adds one second, then two seconds; it never sleeps or measures a real service's recovery time.

Delivery Injected condition Actual attempts Observed result
Q-101: Amber lamp Category missing 1 Business stop; pending human review
Q-102: Cobalt tray Two pre-insert outages 3 Completed; receipt CAT-001
Q-103: Olive frame Confirmation lost after local commit 2 Existing receipt CAT-002 recovered
Q-104: Sand basket Destination unavailable throughout 3 Exhausted; pending human review
Q-105: Olive frame redelivery Same key and unchanged payload 1 Existing CAT-002; no additional write
Q-106: altered Olive frame Same key, different category 1 Payload conflict; pending human review

The store contained exactly two records after all six deliveries. Q-103's first attempt inserted the frame before raising the simulated acknowledgement error. Its second attempt found the matching digest and returned the same receipt. Q-105 exercised another delivery of the completed request, while Q-106 checked that duplicate protection would not silently accept altered input.

Q-102 and Q-104 began their attempts at virtual seconds zero, one, and three. The recovered frame needed only the first one-second backoff. Invalid business data and conflicting payloads scheduled no backoff. The event log records starts, technical errors, virtual delays, writes, existing-record reads, and business stops so those claims can be checked against the actual run.

An intentionally unsafe contrast appended the same demonstration card twice after a simulated lost confirmation. Its two list entries illustrate the defect that blind repetition creates. The guarded catalog run demonstrates a specific local protection; the unsafe list and guarded dictionary are simplified implementations, not an equivalent distributed-system benchmark.

Twelve authored checks passed in each fresh execution, including bounded exhaustion, no retry for the business case, unchanged-receipt redelivery, changed-payload refusal, and the two-write total. The script ran the complete scenario twice with fresh stores and asserted equality before saving both result files. Identical results support repeatability under these injected faults, without establishing reliability against unmodeled failures.

Show the recovery boundary a reviewer can replay

Package the fixture so a reviewer can reproduce those results without credentials. Include workflow.py, the input queue, run-results.json, and the identical fresh replay result. Explain that the script uses Python's standard library and writes only local evidence files. Keep the command short enough to read and copy:

python evidence/workflow.py

A reviewer should be able to find the event that changed destination state, then follow the next attempt's decision. For Q-103, that means locating the first write, the lost-confirmation error, and the existing-record read. A terminal summary alone would hide the most important distinction in this example.

The run also needs an explicit stopping rule. There is no fourth automated attempt for Q-104, and holding the item does not convert it into a completed transaction. A real workflow may need separate retry budgets for browser interaction, transaction processing, and queue redelivery. Document their combined ceiling so nested retries do not multiply destination actions unexpectedly.

The local dictionary and digest check deliberately leave important work unfinished: durable storage, concurrent claims, crash recovery, timeout behavior, access permissions, and reconciliation with an external application's authoritative record. List those as untested boundaries rather than implying that “idempotent” covers every failure mode.

Asset two: a completed handoff packet

The second deliverable uses a separate request, H-207, for an Indigo folio in the stationery category. Its own empty store and continuously unavailable destination produce three pre-insert failures. This case is independent of the first queue's successful frame recovery, and its purpose is to preserve enough context for a later decision.

The generated packet contains the full synthetic input, input digest, key folio-indigo, last checkpoint “before insert,” three attempts at virtual seconds zero, one, and three, and the complete error history. A read of that case's local store confirms zero writes. The disposition is “hold; no automated fourth attempt.”

The proposed owner field names a fictional catalog-operations reviewer role; it does not identify or assign a real person. The packet records human acknowledgement as false, and its disposition holds the item without a fourth attempt. No Action Center task, ticket, email, or calendar event was created. Its completed output is a reviewable packet, not a claim that someone took over.

Here is the full unsent handoff note saved with that packet:

H-207 is held after three pre-insert failures at virtual seconds 0, 1, 3. The local mock has no folio-indigo record. Please reconcile the destination before authorizing a new run; no person has accepted this item.

The proposed next step is to inspect the destination by key and digest before approving replay. The resume condition requires an explicit reviewer decision, restored destination availability, and unchanged matching input. None of those permissions was granted by the script. Local absence establishes only this mock's state; it cannot establish that a different real system has no record.

For a production design, a reviewer might correct the input, reject the request, or authorize a reconciled replay. Record the chosen action and decision authority separately from the automation's technical retry count. Do not infer approval from the existence of a packet or from a notification being sent.

An illustrated held parcel, attempt tokens, and a review folder wait beside an empty handoff chair.

Keep human review separate from automatic success

UiPath's Action Center introduction describes long-running workflows that suspend for human input and resume through configured activities. It also describes user access and licensing requirements. This is useful platform context for explaining a future implementation; the local packet does not demonstrate those capabilities operating.

A credible portfolio separates three states: review requested, a person has accepted responsibility, and an authorized decision has been applied. The mock reaches only the first conceptual state, with an unassigned packet saved locally. A real integration would need evidence of ownership, permissions, persistence, and the path back into processing.

The handoff should also preserve uncertainty. If a real timeout occurs after a possible write and no authoritative lookup is available, mark the commit state unknown. Do not label it “nothing happened” because the client saw an exception. That uncertainty can be the reason to stop rather than a reason to retry harder.

Keep logs useful without exposing secrets. This synthetic example can include full invented inputs. A workplace artifact should use approved redaction and retention rules, avoid credentials or unnecessary personal information, and retain correlation fields that let an authorized reviewer locate the original record securely.

Present the evidence as operational judgment

Lead your project page with the process boundary and actual result: a finite local queue exercised invalid data, transient failures, lost acknowledgement, redelivery, payload conflict, and exhaustion; two records were written and unresolved items stayed pending. Then link the source, results, and independent handoff packet in that order.

A concise portfolio bullet could read: “Built and executed a Python-only RPA recovery simulation with bounded attempts, payload-aware duplicate protection, and an unassigned human-review packet; twelve checks passed on two fresh runs.” Add that it is a simulation so the reader does not infer UiPath deployment experience from the subject matter.

During an interview, explain one deliberate limitation before discussing expansion. For example, an in-memory receipt cannot survive a restart. A proposed next step is to design durable claims and reconciliation around the destination's actual transaction semantics, then test restart and concurrent-delivery cases. That work has not been performed in this portfolio fixture. That is a stronger discussion than assigning a production reliability percentage to a tiny mock.

Organize the target roles, tailored resume version, and project evidence with LandOffer’s job search, then choose the links relevant to each application. Keep this project's strongest links close to its claims: an actual failure trace, the observed recovery decision, and a handoff that honestly remains unresolved.

Download the worked example files

Download the curated educational companion. Read PUBLICATION-README.md after extraction for the public file layout, replay commands and requirements. The listed offline Python checks were rerun from the extracted archive in a disposable directory. The earlier local report and commands describe the original evidence environment; use the companion README for the portable layout. No whole evidence directory, credentials or compiler binaries are included.

Sources and Further Reading