---
title: "Workday Orchestrate shows success but steps failed: debug"
description: "Why an orchestration run can show Success while steps failed, with the exact run statuses, the error-handler and HTTP retry-policy causes, and how to find the…"
url: https://kiweely.com/guides/orchestrate-errors
---

# How do I debug a Workday Orchestrate orchestration that shows success but some steps failed?

A run can look successful because an unsuccessful HTTP response is not a failure unless a retry policy defines a success range, and an error handler set to Conditional Outputs lets the run carry on. Read the run’s per-process stepsFailed, not the status.

-   **Checked** against Workday on November 16
-   Applies to **Workday Orchestrate for Integrations and Extend orchestrations**
-   6 min read
-   Published September 18
-   By Kiweely

A Workday Orchestrate run can show a success-looking status while steps in it did not do their work, because Workday does not count an unsuccessful HTTP response as a failure unless you define an HTTP retry policy with a success range, and an error handler set to Conditional Outputs lets the run continue past an error. To find the step, open the run’s activity, read the per-process `stepsFailed`, then check the logs for the step name.

The statuses and component behaviour below are from Workday’s Orchestrate documentation. Workday does not publish the text of every runtime error, so this page quotes only the statuses, settings and messages the documentation names.

## What statuses can an orchestration run have?

Orchestration Activity, on an app’s page of the Developer Site, lists these for a run:

| Status | Documented meaning |
| --- | --- |
| `RUNNING` | In progress. |
| `AWAITING_CALLBACK` | Paused, waiting for an external callback. |
| `SUCCESS` | Completed successfully. |
| `CANCELLED` | Cancelled before completion, at the next safe cancellation checkpoint. |
| `KILLED` | Killed before completion, immediately. |
| `COMPLETED_WITH_ERROR` | “The orchestration completed but encountered processing errors.” |
| `QUEUED` | Waiting to be executed. |
| `TIMED_OUT` | Did not complete in the expected time. |
| `FAILED` | Failed to complete successfully. |

The Insights API reports the same states plus `FAILED_NOT_EXECUTED`, for an orchestration that failed to launch. In the Orchestration Activity summary bar, green is Completed, yellow is Completed with errors, red is Failed, timed out or cancelled, and blue is running or awaiting callback. A yellow run finished, and Workday flags that it hit processing errors. Start there before trusting green.

## Why does the run show success when an HTTP call returned an error?

Because the step did not fail. The Define HTTP Retry Policies page says that to make an unsuccessful HTTP response fail your orchestration you must create a custom HTTP retry policy with a defined success range, and that “in the absence of such a policy, an unsuccessful HTTP response doesn’t cause an orchestration to fail.”

So a Send Workday API Request or Send HTTP Request step that gets a 400 or 500 back completes, the orchestration moves on, and nothing marks it failed. The same applies to calls made inside sub-orchestrations, which is why they report Completed ([sub-orchestrations that show Completed when an API call fails](https://kiweely.com/guides/workday-orchestrate-sub-orchestration-completed-on-api-error)).

The fix is on the step:

1.  In Orchestration Settings, open **HTTP Retries** and create a policy.
2.  Under **Successful Response Code Ranges**, add the range you accept, for example 200 to 299.
3.  Set **Maximum Total Retries** (up to 60) and a backoff, or set retries low if the call must not repeat.
4.  On the step’s **Settings** tab, in **Retry Settings**, select the policy. It is available on Send HTTP Request, Send WWS Pagination API Request and Send Workday API Request.

For SOAP, the `isSoapFault` function returns true when a document is XML and contains a SOAP 1.1 or 1.2 Fault, so a SOAP fault can be tested for explicitly.

## Why did the run continue after a step failed?

Probably an error handler. Orchestration Builder lets you attach a local error handler to a step or group of steps, and a global one for anything not caught locally. The handler has two modes:

-   **Propagate Error** runs the handler’s steps and rethrows the error to the parent handler, or the global handler if there is none. The run then fails.
-   **Conditional Outputs** runs the handler’s steps and outputs a boolean `isSuccess`. `true` means the guarded step worked and its outputs are available downstream. `false` means only `isSuccess` is available. The run carries on.

A handler in Conditional Outputs mode that does nothing but continue is a step that failed with the run still going. Check each handler for what it does with `isSuccess = false`. Also note what Workday says about downstream steps: if they read the primary outputs of a failed step without checking `isSuccess`, Orchestration Builder rethrows the error.

The handler cannot read the failing step’s exception message. It starts with the same data the step began with, plus a `processingError` output. Add a **Log** step in the handler and write the `message` or `locationPath` member function of `processingError`. `message` returns the error text with the error type in front and the qualified step ID at the end; `locationId` returns the step’s ID. Workday says the message is for logging only, so don’t branch on its text.

## Can a sub-orchestration hide the failure from the parent?

Yes. Workday’s modular design guidance describes two choices in a sub-orchestration: propagate the error so the sub-orchestration’s global handler or the parent marks the run failed, or handle it locally and set outputs that describe the failure. With the second, the parent’s Call step finishes normally. The guidance is to never assume the call succeeded: expose a small set of fields the parent can always rely on, such as `status`, `errorSummary` and `errorDetails`, and branch on `status` before using the outputs.

## What does Continue on Conditions do when its test is false?

If the assertion evaluates to true the orchestration continues. If false, per the reference, “the orchestration stops and Orchestration Builder logs the specified message.” Put a clear message in each assertion. It is the text you will search for in the logs.

## How do I find which step failed?

1.  **Orchestration Activity.** Open the orchestration, find the run, and expand **Current Status** to reach its logs with the run’s filter applied. Note the Run ID, the Common Request ID and the Process IDs.
2.  **Insights API.** `GET /reporting/v1.1/apps/{appId}/orchestrations/{orchName}/runs/{runId}` returns the run with `computeDuration`, `elapsedDuration` and, for each process, `stepsSuccessful` and `stepsFailed`. Event data is kept for 29 days.
3.  **Logs.** In Orchestration Builder, Run Logs (and API Logs) show the run on the tenant. Useful fields: `wd_orch_name`, `wd_orch_step_name`, `wd_response_code`, `wd_path` and `wd_message`. Filter `wd_level` to `ERROR` and `WARN`. Workday deletes logs older than 30 days.
4.  **Orchestration Summary Report.** Generate it from the Orchestration Activity tab; it is a JSON file with `successCount` and `failureCount` for each step in each process.
5.  **Step debugger.** Run the step with its recorded inputs. Debugging is unavailable for Trigger Business Process, Trigger Integration, Trigger PDF Generation and Send HTTP Request steps that use polling. An orchestration built on the Integration System template, or one with certain components such as Store Document, Log to File or Add Integration Message in a sub-orchestration, must be deployed to a tenant and run once before you can debug it.

## Worked example: an update loop that reports success

An Integration System orchestration reads three workers from a report and, in a loop, sends one Send Workday API Request per worker to update an email address. Logan McNeil’s request is rejected with a 400 because the new value is invalid; the other two succeed. The run ends and the team sees green.

1.  Open Orchestration Activity. Nothing in the status points at the 400: the step itself completed.
2.  In the logs, filter `wd_response_code` to 400 and `wd_orch_step_name` to the update step. One entry appears, for Logan McNeil’s request.
3.  Cause: the step has no HTTP retry policy with a success range, so the 400 was accepted as a completed step.
4.  Fix: create a policy with a success range of 200 to 299 and select it in the step’s Retry Settings. Add an **Add Integration Message** step (Integration System template) with severity `ERROR` and a condition for the failing case, so the failure is written to the integration event in the tenant.
5.  Re-run the same three workers. The run now fails, or goes to your error handler, on Logan McNeil’s request, and the other two are the proof the good path still works.

## What do I check before calling it fixed?

Run the affected path again with a record that is known to fail and one known to pass, read the status in Orchestration Activity, read `stepsFailed` in the Insights API, and read the destination record back. A quiet log or a green run proves the run finished, not that the work happened. If the failure is a timeout rather than a status problem, see [keeping large loads inside the runtime limits](https://kiweely.com/guides/workday-orchestrate-runtime-limit-large-loads), and for where each logging step writes, see [logging in Orchestrate](https://kiweely.com/guides/workday-orchestrate-logging).

## Frequently asked questions

### Does an HTTP 400 or 500 response fail a Workday orchestration?

Not by default. Workday states that without a custom HTTP retry policy that defines a successful response code range, an unsuccessful HTTP response does not cause the orchestration to fail. Define a policy with a success range such as 200 to 299 on the step.

### What are the run statuses in Orchestration Activity?

RUNNING, AWAITING\_CALLBACK, SUCCESS, CANCELLED, KILLED, COMPLETED\_WITH\_ERROR, QUEUED, TIMED\_OUT and FAILED. The Insights API adds FAILED\_NOT\_EXECUTED for a run that failed to launch.

### Where do I see how many steps failed in a run?

The Insights API run detail returns, for each process, stepsSuccessful and stepsFailed. The Orchestration Summary Report gives successCount and failureCount per step.

### Can the error handler read the failing step's error message?

Not directly. The handler cannot read the failing step's exception message, but it receives a processingError output with the error's location, and you can write the message out with the Log component. Workday says not to base logic on the message text.

### Why can't I debug the failing step in Orchestration Builder?

Debugging is unavailable for Trigger Business Process, Trigger Integration, Trigger PDF Generation and Send HTTP Request steps that use polling. Integration System orchestrations must be deployed and run once on a tenant first.

## Sources checked

-   [Concept: Orchestration Activity](https://developer.workday.com/documentation/GUID-fe14647a-603a-43a1-a33a-c920d5c90934)
-   [Define HTTP Retry Policies](https://developer.workday.com/documentation/GUID-d04cc763-a044-423f-b39e-1348dfd76a87)
-   [Handle Errors](https://developer.workday.com/documentation/GUID-13ff2639-de8c-43c4-932a-e109fd3c8567)
-   [Concept: Insights API](https://developer.workday.com/documentation/GUID-1d6a3cc0-0528-400b-9f20-c6150420838f)
-   [Reference: Continue on Conditions](https://developer.workday.com/documentation/GUID-cca8cc3e-f013-44b8-bf49-187249b92294)
-   [Debug Orchestrations](https://developer.workday.com/documentation/GUID-491f0056-a020-45bc-8b5e-79163e9152e5)
-   [Concept: Orchestration Builder Logs](https://developer.workday.com/documentation/GUID-151504dc-71a4-48c0-8c8d-3d17a478d3e4-enHYPHENus)
-   [Modular orchestration design (Workday Education)](https://doc.workday.com/workday-education/en-us/course-manuals/creating-integrations-using-workday-orchestrate/modular-orchestration-design.html)

## Related guides

[All guides](https://kiweely.com/guides)

-   [### Why Workday sub-orchestrations and BP orchestrations show Completed when an API call fails By default, Send Workday API Request sets isSuccess to true whenever Workday returns a response, even a SOAP fault or validation error. Use a custom HTTP retry policy, Continue on Conditions with isSoapFault(), or an Integration System orchestration with Add Integration Message to surface failures.](https://kiweely.com/guides/workday-orchestrate-sub-orchestration-completed-on-api-error)
-   [### How to keep large Workday Orchestrate loads inside the runtime limits: templates, checkpoints, batches and child runs First find the limit you hit: 25 seconds for a page call, 5 minutes synchronous, 60 minutes per process (45 before production), or 200 MB in memory. Then use an Integration System or async template, add checkpointing steps, batch writes and split work into child integrations.](https://kiweely.com/guides/workday-orchestrate-runtime-limit-large-loads)
-   [### Logging in Workday Orchestrate: Log, Log to File, Add Integration Message and verbose logging The Log step writes to the app logs on the Developer Site, kept 30 days. Add Integration Message writes to the integration event in the tenant. Log to File builds a named CSV log you attach with Store Document. Verbose logging is a time-limited REST switch for troubleshooting.](https://kiweely.com/guides/workday-orchestrate-logging)
-   [### HTTP retry policies and polling in Workday Orchestrate: how they work and how to configure them Retry policies and polling are set in Settings and chosen on the HTTP step. A policy allows up to 60 retries with backoff and defines success; without a success range, a failed response does not fail the run. Polling waits on an external job up to 48 hours, never on Workday APIs.](https://kiweely.com/guides/workday-orchestrate-http-retry-polling)

### More guides on Orchestrate

[All 86 guides](https://kiweely.com/guides#orchestrate)

-   [Why does an Orchestration JSON path put a leading space in a WID?](https://kiweely.com/guides/workday-orchestration-json-path-leading-space-wid)
-   [How do I stop Orchestrate JSONPath from corrupting WIDs with spaces?](https://kiweely.com/guides/workday-json-path-wid-leading-whitespace-prevention)
-   [How do I fix “WCPISU is not configured” on an Extend orchestration?](https://kiweely.com/guides/workday-extend-wcpisu-not-configured-error)
-   [When to use Workday Document Transformation instead of Orchestrate or Studio](https://kiweely.com/guides/workday-document-transformation-connector-when)
-   [Start with a Workday packaged connector before custom Studio](https://kiweely.com/guides/workday-packaged-connector-before-studio)
-   [Three cases where Workday still wants Studio](https://kiweely.com/guides/workday-studio-three-cases-keep-studio)
-   [Orchestrate is not a bulk-load replacement for Workday EIB or Studio](https://kiweely.com/guides/workday-orchestrate-not-a-bulk-load-replacement)
-   [Why Workday Orchestrate Trigger Integration will not launch an EIB](https://kiweely.com/guides/workday-trigger-integration-cannot-launch-eib)

### From the blog on Orchestrate

[All posts](https://kiweely.com/blog)

-   [How Kiweely Vine designs, builds, deploys, tests and monitors a Workday Orchestration for Integration](https://kiweely.com/blog/workday-orchestration-for-integration-with-kiweely)
-   [Why Workday Studio Remains Essential in an Orchestrate World](https://kiweely.com/blog/why-workday-studio-still-matters-with-orchestrate)
-   [Debugging Workday Extend apps and orchestrations in kiweely](https://kiweely.com/blog/debugging-workday-extend-apps-orchestrations-kiweely)

## Let Workday check the work.

Kiweely writes WQL and builds orchestrations in your own tenant, and Workday, not Kiweely, says whether they passed.

[Start for free](https://kiweely.com/download) [See how it works](https://kiweely.com/vine/how-it-works)

## Get the next guide in your inbox.

One email a month with new guides and one Extend tip. Nothing else.
