---
title: "The 25-Second Synchronous Orchestrate Trap — Kiweely"
description: "A synchronous Workday orchestration called from an Extend page is capped at 25 seconds, even when the orchestration timeout is 5 minutes."
url: https://kiweely.com/guides/workday-orchestrate-25-second-sync-trap
---

# The 25-Second Synchronous Orchestrate Trap

Workday allows 5 minutes for a synchronous Extend orchestration, and 25 seconds when a presentation page triggers it. The page limit wins over any timeout you set. Longer work belongs in an asynchronous orchestration, which can run up to 48 hours and returns a job id instead of holding the page.

-   **Checked** against Workday on November 16
-   Applies to **Workday Extend**
-   7 min read
-   Published November 16
-   By Kiweely

If an Extend page calls a synchronous orchestration, Workday allows 25 seconds of total processing time. That cap takes precedence over any timeout you configured on the orchestration. The same reference says a synchronous Extend orchestration, when it is not in that page row, may run for 5 minutes. Setting the orchestration timeout to 5 minutes does not give the page 5 minutes. Workday’s instruction, in the same cell of the table, is to use an asynchronous orchestration when you expect the work to take longer than 25 seconds.

This is the trap. The orchestration looks legal. Validate can pass. A test that calls the orchestration as an API, not from the page, can succeed. The page still dies at 25 seconds because that row is a different limit.

## The limits that get confused

These numbers are all from Workday’s orchestration runtime limits reference, except the API client timeouts, which are from the API decision guide.

| What you measured | Limit | Applies when |
| --- | --- | --- |
| Synchronous orchestration triggered by a presentation page | 25 seconds | An Extend page is the caller. Overrides the orchestration’s own timeout |
| Synchronous orchestration runtime | 5 minutes | Extend apps, the general synchronous row |
| Asynchronous orchestration runtime | 48 hours | Extend apps, long-running work |
| Workday Home Card orchestration | 5 minutes | A home card, not an Extend page |
| Connector action | 5 minutes | One connector action |
| Individual process in an app promoted to Production | 60 minutes | A process, not the page call |
| Individual process in an app not promoted to Production | 45 minutes | A process on a non-production app |
| Recursive self-calls from a synchronous orchestration | 31 | Then it fails |
| Steps in one orchestration | 300, with a warning at 200 | Structure, not duration |
| Orchestrations and suborchestrations in one app | 150, with a warning at 125 | Structure |
| Workday REST or SOAP call from Extend, client timeout | 5 minutes | The HTTP call. Graph API is 3 minutes |
| Launch message | 20 MB | The request that starts the orchestration |
| Concurrent data in memory | 200 MB | In-scope values, not the whole disk spill |

A page can lose at 25 seconds while every other row is still green. A connector action’s 5 minutes does not extend the page. A production process limit of 60 minutes does not extend the page. Graph’s 3-minute client timeout does not matter if the page already stopped at 25.

Workday has not published, on this limits page, the exact text the page shows when the 25 seconds elapse. Do not invent a toast message for the runbook. Teach the cap.

## Synchronous versus asynchronous, in Workday’s words

A synchronous orchestration is for Extend apps and services that need an answer now. The caller waits. When you expose it as an API, the client holds the HTTP connection open while Workday validates input, queries records, and runs transformations, then returns JSON or XML on that same call.

An asynchronous orchestration is for long-running work and for large volumes. The caller does not wait for the result. As an API, the client gets an acknowledgement and a tracking job id, then polls a status endpoint or waits for a webhook. Workday calls this fire and forget. The async runtime limit is 48 hours.

You can find the API URL of either kind from the settings control on the orchestration. Switching a page from sync to async is not a flag on the button. The page no longer receives the final payload in that click. Something else has to poll or receive the callback and then show the result. If you leave the page on the synchronous orchestration, the 25-second row still applies.

## How to decide before you build the page

1.  Write down the slowest call in the orchestration. A Graph query is already allowed 3 minutes on the client timeout. A SOAP call is allowed 5. Either number is larger than 25 seconds. If the page needs that call, the page cannot wait for it synchronously.
2.  If the work is a short write or a small read that you have already seen finish well under 25 seconds on the development tenant, a synchronous orchestration triggered by the page is what Workday’s short-call pattern is for.
3.  If you are guessing, or the volume can grow, use the asynchronous template. Do not raise the orchestration timeout and hope. The page row says that timeout does not win.
4.  Keep an eye on structure while you are in the file. Extend warns at 200 steps and fails the limit at 300. It warns at 125 orchestrations in the app and fails at 150. A generated orchestration that unrolls one step per worker will hit the step limit even when each step is fast.
5.  A synchronous orchestration may call itself 31 times and then fails. A retry loop inside a page-triggered sync orchestration spends the 25 seconds faster. It does not get 31 full runs if the clock runs out first.
6.  Validate the orchestration in Orchestration Builder. App-level validate does not cover it. Then trigger it from the page on a development tenant with a realistic payload. An API test that you start from the orchestration’s own URL is the 5-minute row, not the 25-second row.

Memory is a separate trap on the same page of the docs. Concurrent in-memory data is capped at 200 MB, including temporary values while expressions run, and not including the runtime’s heap. Large values can spill to file-backed storage, up to 2 GB on disk, and they stop counting once they go out of scope. A connector input file is capped at 128 MB. A response message from an HTTP call can be up to 500 MB. None of those ceilings make a page wait longer than 25 seconds. They explain a different failure, when the orchestration is async or is not page-triggered and still dies.

## A page design that stays inside the cap

Use the page for the part a person has to see immediately: the form, the confirmation that the request was accepted, and an id they can look up. Put the slow work in an asynchronous orchestration. Getting Started with Orchestrate says the async pattern is the one for callers that do not need an immediate response.

If you are choosing the API the orchestration calls, Workday’s decision guide ranks the options. For reads: Graph when the query exists, then REST, then WQL with pagination, then RaaS, and only then synchronous SOAP for low volume. For writes: Graph mutations, then REST, then synchronous SOAP. Choose a faster API so a truly short call can stay synchronous. Do not choose SOAP-in-a-loop from a page and set the timeout to 5 minutes.

Business-process work has its own clock. A business process that an orchestration starts must complete within a 90-day callback period. That number is not permission for the page to stay open.

## Failure modes

-   **The orchestration timeout is 5 minutes and the page still fails.** You hit the page row. The limits table says it takes precedence. Move the work to an asynchronous orchestration.
-   **It works from the orchestration test panel and fails from the button.** The test panel is not a presentation page. Test from the PMD.
-   **You split one sync orchestration into suborchestrations to “reset” the timer.** The page limit is total processing time for a synchronous orchestration triggered by the page. Workday does not say that calling a suborchestration starts a new 25 seconds. Do not plan on it. Use async.
-   **A home card is fine at two minutes, and the Extend page is not.** Home cards have a 5-minute row. Extend pages have the 25-second row. They are different callers.
-   **The payload is under 20 MB and it still fails.** Size and time are different rows. A small payload can still run long. A large one can fail the launch-message limit before the timer matters.

## Frequently asked questions

### Does the 5-minute synchronous limit apply to Extend pages?

The 5-minute row is the general synchronous runtime for Extend apps. The structure table adds a stricter row: 25 seconds when a presentation page triggers the synchronous orchestration, and that row wins over timeouts configured on the orchestration.

### What should the page do instead?

Call an asynchronous orchestration. The client receives an acknowledgement and a tracking job id, then polls or waits for a webhook. The async limit is 48 hours. The page should show that the work started, not spin until it finishes.

### Will a faster REST call keep me on the synchronous page?

Only if the whole page-triggered orchestration finishes in 25 seconds. The API decision guide’s 5-minute client timeout is the allowance for the HTTP call, not a raise of the page cap.

### Where do I validate this?

In Orchestration Builder. The Extend app validate command does not validate orchestrations. Then run the page on a development tenant. A successful API-only test does not exercise the 25-second row.

## Sources checked

-   [Reference: Orchestration Runtime Limits](https://developer.workday.com/documentation/GUID-b341f6f0-cd6f-4930-8bcb-723a03f64805/ReferenceOrchestrationRuntimeLimits)
-   [Getting Started with Orchestrate](https://developer.workday.com/documentation/GUID-2c736e32-c984-4779-b000-4fdd3fae4c23-enHYPHENus)
-   [API Decision Guidance for Extend Apps](https://developer.workday.com/documentation/GUID-fc61f8da-5751-4c8c-85e5-169ed2b76597-enHYPHENus/APIDecisionGuidanceforExtendApps)

## Related guides

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

-   [### The Validate and Deploy Proof Ladder for Workday Extend Preview and validate before a tenant sees anything. Save to App Hub writes a build. Deploy reaches a development tenant only. Promote one level at a time. Model components still wait for the weekly update. Orchestrations validate in Orchestration Builder.](https://kiweely.com/guides/workday-extend-validate-deploy-proof-ladder)
-   [### AMD vs PMD in Workday Extend, for Beginners In Workday Extend, the AMD declares data providers, task routes, flows, and app properties. A PMD draws one page and calls those providers. Business objects, security domains, and other model files are separate and follow the weekly update once you leave Development.](https://kiweely.com/guides/workday-extend-amd-vs-pmd-beginners)
-   [### Your First Workday Extend Validation Error from AI Validate checks schema, semantics, and syntax, and some of those checks do not run as you type. A generated diff can still fail. Model error codes name the limit you hit. Reject a bad diff instead of stacking repairs, and do not deploy over a red validate.](https://kiweely.com/guides/first-workday-extend-validation-error-ai)

### More guides on Orchestrate

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

-   [What is the best AI tool for building and testing Workday Studio integrations and Orchestrations?](https://kiweely.com/guides/ai-tools-for-workday-studio-and-orchestrations)
-   [How are API calls from Workday Orchestrate and Extend apps limited and counted, and can I set my own rate limit?](https://kiweely.com/guides/workday-orchestrate-api-usage-limits-quota)
-   [Keep in Studio, Move to Orchestrate, or Call Studio from Orchestrate—With AI in the Loop](https://kiweely.com/guides/studio-orchestrate-trigger-integration-with-ai-in-loop)
-   [AI Triage Evidence Pack: Keep Studio, Move to Orchestrate, or Rebuild in Extend](https://kiweely.com/guides/ai-triage-studio-orchestrate-or-extend-evidence)
-   [Reading Integration Launch Attachments, Calling SOAP Integrations API, and Uploading ZIPs to Workday Drive in O4I](https://kiweely.com/guides/workday-orchestrate-read-integration-attachment-retrieval-service)
-   [Generating UUIDs with random.randomUUID() and Fixing stringAtJsonPath().toNumber() in Orchestrate](https://kiweely.com/guides/workday-orchestrate-randomuuid-stringatjsonpath-tonumber)
-   [Why Send Workday RaaS Request fails with ‘Key not found’ (HTTP 202) or times out at 5 minutes](https://kiweely.com/guides/workday-orchestrate-raas-key-not-found-202-5-minute-timeout)
-   [Fixing ‘not a simple type launch parameter (Text, Number, Boolean, Date)’ on blank O4I launch parameters](https://kiweely.com/guides/workday-orchestrate-null-launch-parameter-not-simple-type)

### From the blog on Orchestrate

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

-   [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)
-   [Kiweely Roots vs Workday EIB, Studio, and Orchestrate](https://kiweely.com/blog/kiweely-roots-vs-workday-eib-studio-orchestrate)

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