---
title: "Workday Studio PutIntegrationMessage Severity and Aborts"
description: "How Workday Studio is.message.severity (INFO, WARNING, ERROR, CRITICAL, DEBUG), local send-error handlers, and MediationContext abort flags set event status."
url: https://kiweely.com/guides/workday-studio-error-severity-critical-warning-abort
---

# How Workday Studio PutIntegrationMessage Severity Levels Control Completed-with-Warnings vs. Aborted Runs

In Workday Studio, PutIntegrationMessage updates the integration event status in Process Monitor based on is.message.severity, but it never stops assembly execution by itself. Pair CRITICAL messages with error handlers or MediationContext abort flags to halt a run cleanly.

-   **Checked** against Workday on November 13
-   Applies to **Workday Studio**
-   6 min read
-   Published November 13
-   By Kiweely

Setting `is.message.severity` on `PutIntegrationMessage` changes the integration event status shown in Workday’s **Process Monitor** (`Completed`, `Completed with Warnings`, `Completed with Errors`, or `Failed`), but **never stops or branches your assembly flow by itself**. If a local validation routes to `PutIntegrationMessage` with `'CRITICAL'` or `'ERROR'` and its normal path continues to an `sftp-out` or `store` step with `is.document.deliverable` enabled, Workday marks the event red while still delivering a partial or corrupted file to the vendor.

To make severity levels match actual runtime behavior, you have to pair `PutIntegrationMessage` with explicit flow control: local `send-error` handlers (`rethrow-error`), global error handlers, conditional delivery gates, and `MediationContext` abort propagation (`propagate-abort="true"`).

## How Each `is.message.severity` Value Changes Process Monitor Status

The `PutIntegrationMessage` common component (`vm://wcc/PutIntegrationMessage`) accepts five literal strings on its `is.message.severity` parameter (defaulting to `'INFO'`). Workday evaluates event status using a high-water mark across the entire run: a later `'INFO'` summary message never downgrades an earlier `'WARNING'`, `'ERROR'`, or `'CRITICAL'` status.

| `is.message.severity` Value (or Runtime Event) | Resulting Event Status in Process Monitor | Does Assembly Execution Stop Automatically? | When to Use It |
| --- | --- | --- | --- |
| `'DEBUG'` / `'INFO'` (default) |  **Completed** | No | High-level run milestones (for example, record counts extracted and delivered). |
| `'WARNING'` |  **Completed with Warnings** | No | Non-blocking data anomalies where the worker record is still valid (for example, defaulting an optional cost center code). |
| `'ERROR'` |  **Completed with Errors** | No (unless an unhandled exception unwound the assembly) | Record-level data rejections where one bad worker or invoice is skipped, while valid records still deliver. |
| `'CRITICAL'` |  **Failed** |  **No**—only sets event status to **Failed** unless paired with an error unwind or abort | System-wide failures (SOAP/REST auth failure, missing required launch parameter, SFTP outage, or threshold exceeded) where **no file** may be delivered. |
| Unhandled exception with no error handler |  **Completed with Errors** | Yes—runtime unwinds and terminates the assembly | Never rely on this by accident; raw Java stack traces confuse functional admins. Always add a Global Error Handler that posts `'CRITICAL'`. |
| Manual cancel in Process Monitor / `MediationContext` abort |  **Aborted** (or halted subassembly chain) | Yes—`context.setAborted(true)` stops the subassembly and propagates when `propagate-abort="true"` | Operator cancellation in Workday or programmatic emergency stop across nested `local-out` subassemblies. |

Protect your payload and respect the 500-message cap

Because `PutIntegrationMessage` is a `local-out` subassembly that builds a Workday Web Services call on the active `MediationMessage`, always set **Clone Request** (`clone-request="true"`) on its **Advanced** tab whenever downstream steps still need the current XML payload. Also avoid calling `PutIntegrationMessage` inside a per-worker splitter loop: Workday caps the event’s **Messages** tab at **500** plain messages (sending extras to the 48 MB server log) and incurs a web service round-trip on every call. Use Studio’s `cloud-log` step for per-worker detail and reserve [PutIntegrationMessage logging](https://kiweely.com/guides/workday-studio-put-integration-message-logging) for run summaries and status escalation.

## Why `CRITICAL` Alone Still Delivers Bad Files (Fails vs. Works)

This is the single most dangerous bug in [inherited Workday Studio integrations](https://kiweely.com/guides/inheriting-workday-studio-integration). A developer catches a missing map value or failed SOAP lookup in a local `send-error`, calls `PutIntegrationMessage` with `is.message.severity` set to `'CRITICAL'`, leaves `rethrow-error="false"` (the default), and lets the parent splitter/aggregator finish and push the output file to SFTP.

Fails

```
<!-- ANTI-PATTERN: Local send-error logs CRITICAL, marks the error handled,
     and lets the assembly keep running right into SFTP delivery! -->
<cc:async-mediation id="ValidateHeader" handle-downstream-errors="true">
  <cc:steps>
    <cc:validate-exp id="CheckPayGroup">
      <cc:expression failure-message="Pay Group parameter is empty.">
        props['p.payGroupWid'] != empty
      </cc:expression>
    </cc:validate-exp>
  </cc:steps>
  <!-- Default rethrow-error="false" swallows the exception! -->
  <cc:send-error id="CatchHeaderError" routes-to="PostCriticalOnly"/>
</cc:async-mediation>

<cc:local-out id="PostCriticalOnly" endpoint="vm://wcc/PutIntegrationMessage" clone-request="true">
  <cc:set name="is.message.severity" value="'CRITICAL'"/>
  <cc:set name="is.message.summary" value="context.errorMessage"/>
</cc:local-out>
```

Because `rethrow-error` defaults to `false` on `send-error`, Studio marks the error as handled as soon as `PostCriticalOnly` finishes, resumes the upstream chain, and runs any subsequent siblings after the splitter or subassembly!

To guarantee processing stops immediately when a fatal condition occurs, either set `rethrow-error="true"` on the local `send-error` so the exception bubbles up to your **Global Error Handler**, or mark the `MediationContext` aborted and propagate it across `local-out` boundaries:

Works

```
<!-- WORKING PATTERN: Local send-error captures step context, rethrows to Global Error Handler,
     and Global Error Handler posts CRITICAL and halts the assembly before delivery. -->
<cc:async-mediation id="CallWorkdaySoap" handle-downstream-errors="true">
  <cc:steps>
    <cc:eval id="TagStepContext">
      <cc:expression>props['p.failedStep'] = 'Get_Workers SOAP request'</cc:expression>
    </cc:eval>
  </cc:steps>
  <cc:send-error id="CaptureAndRethrow" rethrow-error="true" routes-to="AddDiagnosticContext"/>
</cc:async-mediation>

<!-- Global Error Handler at top level of assembly -->
<cc:send-error id="GlobalErrorHandler" routes-to="LogFatalAndStop"/>

<cc:local-out id="LogFatalAndStop"
              endpoint="vm://wcc/PutIntegrationMessage"
              clone-request="true"
              propagate-abort="true">
  <cc:set name="is.message.severity" value="'CRITICAL'"/>
  <cc:set name="is.message.summary" value="'Integration halted at ' + props['p.failedStep']"/>
  <cc:set name="is.message.detail" value="context.errorMessage"/>
</cc:local-out>
```

When an assembly calls nested subassemblies (`local-in` / `local-out`), inspect the **Propagate Abort** (`propagate-abort`) attribute on every calling `local-out` transport. When a child subassembly calls `context.setAborted(true)` in MVEL (or `mediationContext.setAborted(true)` in Java), it halts that subassembly; `propagate-abort="true"` ensures the calling parent assembly stops too instead of continuing onto its `routes-response-to` path.

## Building an `AbortOnError` Launch Parameter Pattern for Payroll and Finance Feeds

Functional payroll and AP admins frequently want two modes on the same integration:

-   **Dry runs / UAT or strict bank feeds (`Abort on Error` = true):** Any record-level mapping or required-field error must halt the integration **before** `sftp-out` or deliverable `store` runs, marking the event **Failed**.
-   **Lenient incremental feeds (`Abort on Error` = false):** Skip the defective worker record, post an `'ERROR'` (or `'WARNING'`) summary naming the Worker ID and missing field, and still deliver the remaining valid workers (`Completed with Errors` or `Completed with Warnings`).

Implement this cleanly with three pieces:

1.  **Add a Boolean Launch Parameter** named `Abort on Error` on the `workday-in` transport’s **Launch Parameters** tab, and read it once at initialization into `props['p.abortOnError'] = lp.getSimpleData('Abort on Error')`.
2.  **Inside the per-worker splitter**, catch record validation exceptions with a local `send-error` (`rethrow-error="false"`), increment `props['p.errorCount']`, and append the worker’s error row to a `cloud-log` variable rather than hammering `PutIntegrationMessage` 800 times.
3.  **After the aggregator / splitter completes (and strictly before `store` or `sftp-out`)**, evaluate `props['p.errorCount']`:
    -   If `props['p.errorCount'] > 0 && props['p.abortOnError'] == true`: attach the `cloud-log` diagnostic report with `is.document.deliverable` set to `'false'` (so Workday’s **Integration Process Event** delivery service will **not** transmit it to the vendor), invoke `PutIntegrationMessage` with `is.message.severity = 'CRITICAL'`, and route nowhere / call `context.setAborted(true)` so `sftp-out` never fires.
    -   If `props['p.errorCount'] > 0 && props['p.abortOnError'] == false`: attach the `cloud-log` report, invoke one summary `PutIntegrationMessage` with `is.message.severity = 'ERROR'` (for skipped records) or `'WARNING'` (for defaulted fields), and proceed to `sftp-out` with the valid records.

Watch \`is.document.deliverable\` when attaching audit logs

On `PutIntegrationMessage`, `is.document.deliverable` defaults to `'true'`. If your integration system has an SFTP or Email delivery service configured on its Business Process in Workday, attaching a diagnostic `cloud-log` HTML file with `is.document.deliverable` left at `'true'` will send that internal error report straight to the external vendor’s SFTP dropbox! Always set `is.document.deliverable` to `'false'` on internal audit and error files, and apply `'Deliverable'` labels only to the actual vendor payload.

## How to Verify All Four Outcomes Before Deploying to Production

You do not need to pollute a Sandbox tenant with twenty test launches to verify error routing. Use [Workday Studio AUnit tests](https://kiweely.com/guides/workday-studio-aunit-testing) (`com.workday.aunit.AssemblyTestCase`) to mock `vm://wcc/PutIntegrationMessage`, inspect the captured `is.message.severity` property, and assert whether the mock `sftp-out` endpoint was reached under both `Abort on Error = true` and `Abort on Error = false`. Then deploy to Sandbox and trigger one warning run and one forced fatal run, verifying in **Process Monitor** both the final event status and the **Output Files** tab.

In [Kiweely Vine](https://kiweely.com/vine), the assistant writes and runs AUnit suites inside your local Workday Studio automatically whenever it edits error handlers or `PutIntegrationMessage` routes, proving before deployment that `'CRITICAL'` failures actually block outbound delivery.

## Frequently asked questions

### Does setting is.message.severity to CRITICAL in PutIntegrationMessage stop a Workday Studio integration?

No. PutIntegrationMessage only sends a web service update to the Workday integration event in Process Monitor, setting the event status to Failed when severity is CRITICAL. Unless the assembly is already unwinding an unhandled exception in a global error handler or marks the MediationContext as aborted, downstream steps such as SFTP delivery will still execute.

### What is the difference between Completed with Warnings, Completed with Errors, Failed, and Aborted in Process Monitor?

Completed with Warnings means at least one WARNING message was posted and no ERROR or CRITICAL occurred. Completed with Errors means an ERROR message was posted (or an unhandled exception terminated the assembly without a CRITICAL message). Failed is set when PutIntegrationMessage posts CRITICAL, and Aborted occurs when a user cancels a running event in Process Monitor or the runtime aborts execution.

### Why did my integration payload disappear right after calling PutIntegrationMessage?

PutIntegrationMessage is a subassembly invoked over local-out (vm://wcc/PutIntegrationMessage) whose Clone Request property defaults to false. Without Clone Request set to true, PutIntegrationMessage overwrites the active MediationMessage with its own SOAP request and response.

### Why did PutIntegrationMessage stop showing messages on the integration event after 500 records?

Workday caps an integration event's Messages tab at 500 plain PutIntegrationMessage entries per run and diverts additional informational messages to the server log. For record-level warnings across thousands of workers, append entries to a Cloud Log step and attach one HTML or CSV summary file with a store step instead.

## Sources checked

-   [Reference: PutIntegrationMessage Subassembly Properties](https://doc.workday.com/admin-guide/en-us/workday-studio/integration-design/common-components/acj1508493846673.html)
-   [Concept: Error Handler Components](https://doc.workday.com/admin-guide/en-us/workday-studio/integration-design/error-handler-components/egj1510323126986.html)
-   [Reference: Send-Error Component Properties](https://doc.workday.com/admin-guide/en-us/workday-studio/integration-design/error-handler-components/lde1510592263523.html)
-   [Logging and Error Handling in Workday Studio](https://doc.workday.com/workday-education/en-us/course-manuals/creating-integrations-using-workday-studio/logging-and-error-handling.html)

## Related guides

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

-   [### Workday Studio Store, Log, and Put Integration Message: Building Audit Trails Compare Workday Studio’s Log, Cloud Log, PutIntegrationMessage, and Store components. Learn how each step records messages or files, how severity levels control integration event statuses, and how to tag Blobitory documents for downstream delivery services.](https://kiweely.com/guides/workday-studio-put-integration-message-logging)
-   [### Inheriting a Workday Studio Integration You Didn’t Build Every team eventually inherits a Workday Studio integration built by someone who moved on. The assembly works — until it doesn’t. This guide walks through a structured approach to understanding an unfamiliar integration, identifying fragile points, and bringing it under control without regressions.](https://kiweely.com/guides/inheriting-workday-studio-integration)
-   [### Writing Your First AUnit Test for a Workday Studio Integration Most Workday Studio integrations ship without automated tests. AUnit, Studio’s built-in unit-testing framework, can change that. This guide walks through creating your first AUnit test: setting up test data, writing a test case, running it locally, and reading the results.](https://kiweely.com/guides/workday-studio-aunit-testing)
-   [### How to Debug a Failing Workday Studio Integration, Step by Step When a Workday Studio integration fails, the error message alone rarely tells you enough. This guide walks through a structured debugging process: reading Integration Events, isolating the failing step, using Studio’s breakpoint and message-inspection tools, and resolving common error patterns.](https://kiweely.com/guides/debug-workday-studio-integration)

### More guides on Integrations and APIs

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

-   [How to Fix Workday Studio SDKProfile Not Current and Unsigned Software Startup Errors on Mac and Windows](https://kiweely.com/guides/workday-studio-sdkprofile-not-current-unsigned-macos-errors)
-   [How to Authenticate Workday Studio and External Tools Using an OAuth API Client with PKCE (When SSO Blocks Passwords)](https://kiweely.com/guides/workday-api-client-pkce-sso-without-workday-password)
-   [Workday PECI vs. PICOF Payroll Connectors: How Effective-Dated Stack and Retro Changes Export](https://kiweely.com/guides/workday-peci-picof-payroll-connector-change-detection)
-   [Why does my Workday Accounting Journal EIB fail? Balancing, worktag and period errors](https://kiweely.com/guides/workday-financials-accounting-journal-eib-validation-errors)
-   [How to Find Every Domain and Web Service Permission an ISU Needs in Workday (Without Guesswork)](https://kiweely.com/guides/workday-isu-permissions-activate-pending-security-policy-changes)
-   [How to Fix The Load Contains a Duplicate Key and Invalid Reference ID Errors in Workday EIB](https://kiweely.com/guides/workday-eib-duplicate-key-reference-id-errors)
-   [How to Troubleshoot Workday Cloud Connect for Benefits (CCB) and Missing Dependents on 834 Feeds](https://kiweely.com/guides/workday-cloud-connect-for-benefits-834-errors)
-   [Why Workday Scheduled Reports and Integrations Shifted Dates After Local Time Zone Processing](https://kiweely.com/guides/workday-local-time-zone-processing-report-integration-impacts)

### From the blog on Integrations and APIs

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

-   [Turning a Messy Client Spreadsheet into a Clean Workday EIB Load in One Conversation](https://kiweely.com/blog/messy-spreadsheet-to-workday-eib-load-with-ai)
-   [Workday REST API vs. SOAP Web Services: Why Setup Work Still Needs the Task Screen](https://kiweely.com/blog/workday-rest-api-vs-soap-coverage-gaps)
-   [Untangling Inherited Workday Studio Integrations: A Practical Modernization Playbook](https://kiweely.com/blog/untangling-inherited-workday-studio-integrations)

## 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.
