---
title: "Fix batchLoop fast forwarding & 45-min timeouts — Kiweely"
description: "Why combining Send Paged Workday REST Call or RaaS steps with Batch Loop causes 'Fast forwarding to correct position' or 2700000ms process timeouts in O4I."
url: https://kiweely.com/guides/workday-orchestrate-batchloop-paginatedget-fast-forwarding-timeout
---

# Fixing ‘Fast forwarding to correct position’ and 45-minute timeouts in Orchestrate batchLoop

A small RaaS step inside a Batch Loop does not reset the 45-minute process timer and disables pipelining. Passing a paged REST iterator directly into a checkpointing Batch Loop throws ‘Fast forwarding to correct position’. Stage pages in a Loop first, and chunk with Trigger Integration.

-   **Checked** against Workday on November 6
-   Applies to **Workday Orchestrate**
-   5 min read
-   Published November 6
-   By Kiweely

## Why O4I fails after 45 minutes (`2700000ms`) even with a RaaS step inside `Batch Loop`

While a **Workday Integration System** (O4I) orchestration can run for up to **48 hours** in total, Workday divides every orchestration into smaller execution units called **processes**. According to **Reference: Orchestration Runtime Limits**, a single process has a hard execution ceiling:

-   **45 minutes (`2,700,000 ms`)** in an app that has not yet been promoted to a production tenant.
-   **60 minutes (`3,600,000 ms`)** in an app promoted to a production tenant.

When a single process exceeds the non-production ceiling while processing 50,000+ records, the orchestration terminates with:

text

```
Completed with error: Maya integration execution timed out. Did not complete in 2700000ms.
```

Because **Concept: Orchestration Processes** lists **Send Workday RaaS Request** as one of the five checkpointing components (alongside **Trigger PDF Generation**, **Trigger Business Process**, **Trigger Integration**, and polling **Send HTTP Request**), developers frequently place a small dummy **Send Workday RaaS Request** inside a **Batch Loop** hoping to force a checkpoint and reset the 45-minute process timer on every batch.

That workaround fails—and actively degrades performance—for two reasons:

1.  **Short-running RaaS requests do not create a new process ID.** Orchestrate only checkpoints and spawns a new process ID when a **Send Workday RaaS Request** is genuinely long-running and Workday hands it off to execute asynchronously. A small or fast RaaS report returns immediately inside the current process, so no checkpoint occurs and the 45-minute clock keeps counting.
2.  **Placing a RaaS step inside a loop disables loop pipelining.** Normally, Orchestrate pipelines loop iterations to maximize throughput. Including a **Send Workday RaaS Request** inside a **Batch Loop** disables pipelining for that loop, forcing every batch—and every batch API call inside it—to run strictly one after another.

## How to process 50,000 to 250,000+ records without hitting the process timeout

To scale high-volume transformations and Business Object inserts without hitting the 45-minute non-production (or 60-minute production) process limit:

1.  **Remove any dummy `Send Workday RaaS Request` steps from inside your `Batch Loop`.** Removing the RaaS step immediately restores loop pipelining, often cutting batch execution time in half (for example, processing 55,000 joined records in ~21 minutes instead of timing out at 45 minutes).
2.  **Use bulk API endpoints inside the batch loop.** When inserting or updating Extend Business Object records, set the **Batch Loop** **Data Breakpoint Number** to `100` and call the Business Object REST API with `?bulk=true` so each HTTP request writes 100 records at once.
3.  **Spawn genuine process checkpoints with `Trigger Integration`.** When I/O time across 250,000 records will exceed 45 minutes even with pipelining and bulk APIs, split the dataset into large chunks (for example, 25,000 to 50,000 records per chunk) and invoke a child O4I integration for each chunk using **Trigger Integration**. Because **Trigger Integration** is always handed off asynchronously to the integration framework, every invocation is guaranteed to save process state, spawn a new **Process ID**, and reset the 45/60-minute process timer.

## Fixing `"Fast forwarding to correct position"` when combining `Send Paged Workday REST Call` and `Batch Loop`

A second checkpointing error occurs when you feed the streaming iterator of a paginated GET step (**Send Paged Workday REST Call** or **Send Paged HTTP Request**, configured with a page `Limit` such as `10000`) directly into the **Data Set** of a **Batch Loop** (configured with a **Data Breakpoint Number** such as `1000`) that contains a checkpointing step like **Trigger Integration**.

When the orchestration resumes from a checkpoint on the final partial page, it throws:

text

```
Fast forwarding to correct position, expected to find more elements in the next page, but found none. Current resume sub element skip count: 1
```

### Root cause

When a checkpoint step (**Trigger Integration**) runs inside a **Batch Loop**, the current process serializes its cursor position and hands off execution to a new process when the child integration finishes. The new process attempts to reconstruct the exact position in the upstream **Data Set** by re-reading and fast-forwarding the iterator. When the **Batch Loop**‘s **Data Set** is bound directly to a lazy network pagination iterator (`data.PagedRestCall.iterator`) and the final page contains leftover elements that do not fill a full page boundary, the resume fast-forward logic attempts to advance past the end of the paged stream and throws `Fast forwarding to correct position, expected to find more elements in the next page, but found none`.

### How to fix the iterator handoff

Never bind a checkpointing **Batch Loop** directly to a live `Send Paged Workday REST Call` iterator. Instead, materialize or stage the paginated items in a standard non-checkpointing **Loop** first, and pass the materialized collection into the **Batch Loop**:

| Step | Component | Configuration |
| --- | --- | --- |
|  **1\. Fetch pages** |  **Send Paged Workday REST Call** (`FetchWorkersPaged`) | Set **Limit** (for example, `1000` or `10000`) and configure your WQL or REST endpoint. |
|  **2\. Materialize stream** |  **Loop** (`CollectPagesLoop`) | Iterate over `data.FetchWorkersPaged.iterator` with no checkpointing steps inside. Add an **Aggregation** (`JSON Fold`, `CSV Fold`, or `String List` depending on payload shape) to combine all pages into a single local file-backed dataset (`AllRecords`). |
|  **3\. Chunk and checkpoint** |  **Batch Loop** (`ChunkAndTriggerBatchLoop`) | Set **Data Set** to the aggregated output from Step 2 (`data.CollectPagesLoop.AllRecords.iterator()`), set **Strategy** to *Size* (`1000`), and invoke **Trigger Integration** inside the batch. |

Because Workday Orchestrate manages large aggregated datasets on disk in file-backed data structures (supporting up to **2 GB** of concurrent data on disk per orchestration), staging the pages through a fast **Loop** aggregation gives the downstream **Batch Loop** a deterministic, seekable dataset that resumes cleanly across process checkpoints without re-querying or miscounting pagination boundaries.

## How to verify process checkpoints and batch timings in the tenant

1.  Run your Integration System orchestration on a dataset that crosses multiple batches (including a final batch whose size is not an even multiple of your page limit or batch size).
2.  In the Developer Site, open **Orchestration Activity** for the run and inspect the **Process IDs** list under the **Common Request ID**. Confirm that each **Trigger Integration** checkpoint creates a new **Process ID** and that no single process approaches the 45-minute non-production limit.
3.  Generate an **Orchestration Summary Report** (**Generate Orchestration Summary Reports**) for the completed run to inspect the exact wall-clock time spent in I/O operations versus loop processing and verify that `Fast forwarding to correct position` no longer appears in the logs.

## Sources checked

-   [Concept: Orchestration Processes](https://developer.workday.com/documentation/GUID-3274e8db-46ed-4c0b-bedc-e36948e26613)
-   [Reference: Orchestration Runtime Limits](https://developer.workday.com/documentation/GUID-b341f6f0-cd6f-4930-8bcb-723a03f64805)
-   [Reference: Batch Loop](https://developer.workday.com/documentation/GUID-c382cf0c-48d1-4e31-a923-641d245bd06d)
-   [Reference: Send Paged Workday REST Call](https://developer.workday.com/documentation/GUID-cd92b4a3-ee7f-434f-93c9-d10ff3ca29c4)
-   [Reference: Trigger Integration](https://developer.workday.com/documentation/GUID-cb68f51e-56ce-4159-b450-5b5ede1caf59)
-   [Reference: Orchestration Summary Report Details](https://developer.workday.com/documentation/GUID-046dfceb-f16a-4ccc-9357-9fbc1f4ca67b)

## Related guides

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

-   [### Why Send Workday RaaS Request fails with ‘Key not found’ (HTTP 202) or times out at 5 minutes Send Workday RaaS Request defaults to a 300-second timeout unless raised in Orchestration Settings, causing HTTP 406 or 500 errors at 5 minutes. When a RaaS call in a loop returns HTTP 202 (still processing) with an empty body, is2xxStatusCode() passes and parsing crashes with ‘Key not found’.](https://kiweely.com/guides/workday-orchestrate-raas-key-not-found-202-5-minute-timeout)
-   [### Resolving ‘\[StepException\] requirement failed: Input lists must be of the same size’ in createReferenceList The two-list overload InstanceRef.createReferenceList(idTypes: StringList, values: StringList) pairs idTypes\[i\] with values\[i\] and requires equal list lengths. Use the single-String overload InstanceRef.createReferenceList(idTypes: String, values: StringList) when all IDs share one type.](https://kiweely.com/guides/workday-orchestrate-createreferencelist-input-lists-same-size)
-   [### Orchestrate Join Loop explained: missing matches, skipped records, multiple keys and the current layout A Join Loop walks the primary dataset and looks up each record in one or more joining datasets by key. What happens to records with no match or several matches is set by the Missing Match Strategy and Multiple Match Strategy; leftovers are read through JoinResiduals functions.](https://kiweely.com/guides/workday-orchestrate-join-loop)
-   [### Orchestrate Batch Loop: batch size, custom breaks, Group By, batch numbers and missing items Batch Loop splits a dataset into batches by Size (a fixed item count), Custom (a break at or after a matching item) or Group (items sharing a Group By value). Items go missing when Keep Leading Items is clear on a Custom strategy, the Filter removes them, or the Data Set selects the wrong node.](https://kiweely.com/guides/workday-orchestrate-batch-loop)

### More guides on Orchestrate

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

-   [Overcoming ‘Message length should be lesser than 1MB in size’ and ‘Orchestration is too large to be saved’](https://kiweely.com/guides/workday-orchestrate-1mb-message-limit-too-large-to-save)
-   [Handling Silent GraphQL Errors in PMD and Orchestrate When HTTP Status Returns 200 OK](https://kiweely.com/guides/workday-graphql-http-200-silent-mutation-errors)
-   [Avoiding the 25-Second Synchronous Timeout When an Extend Page Calls External LLM APIs Through Orchestrate](https://kiweely.com/guides/workday-extend-async-orchestration-llm-timeout)
-   [Why Log to File Turns XML Closing Tags into <// and How to Write #if Conditions in CreateTextTemplate](https://kiweely.com/guides/workday-orchestrate-xml-double-slash-log-to-file-if-conditions)
-   [Waiting for Import\_Payroll\_Input\_Request Background Processes at Scale in Workday Orchestrate](https://kiweely.com/guides/workday-orchestrate-wait-background-process-import-payroll-input)
-   [Why Workday sub-orchestrations and BP orchestrations show Completed when an API call fails](https://kiweely.com/guides/workday-orchestrate-sub-orchestration-completed-on-api-error)
-   [Why stripHtmlTags and htmlToPlainText Leave HTML Tags Over 2,003 Characters in Workday Orchestrate](https://kiweely.com/guides/workday-orchestrate-striphtmltags-2003-character-limit)
-   [Sorting JsonKeyValueIterator Collections and Numeric String Values in Workday Orchestrate Loops](https://kiweely.com/guides/workday-orchestrate-sort-jsonkeyvalueiterator-numeric-sorting)

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