---
title: "Find Unsubmitted Workday Time Blocks & Project Hours (WQL)"
description: "Query unsubmitted, unapproved, and incomplete Workday time blocks and project timesheet lines via WQL and RaaS before payroll cutoff under constrained security."
url: https://kiweely.com/guides/workday-project-time-tracking-unsubmitted-hours-wql
---

# Finding Unsubmitted Workday Time Blocks and Project Hours with WQL

Query unsubmitted and unapproved Workday time before payroll cutoff using allTimeBlocks, incompleteTimeBlocks, and projectTimesheetLinesForWorkersWithinDateRange in WQL. Pair each query with explicit data source filters so constrained managers and project leads see every permitted row.

-   **Checked** against Workday on November 15
-   Applies to **Workday Time Tracking & WQL**
-   6 min read
-   Published November 15
-   By Kiweely

To find unsubmitted or unapproved hours before payroll cutoff in Workday Query Language (WQL), query **`allTimeBlocks`** (filtering on `isSubmitted`, `isApproved`, and `timeBlockStatus`), **`incompleteTimeBlocks`** (for open clock-ins missing an out time), and **`projectTimesheetLinesForWorkersWithinDateRange`** (for project timesheets across any `timesheetStatus`). Always pass the exact `dataSourceFilter` matching the caller’s role—supervisory manager, timekeeper, or project manager—so Workday’s constrained security groups return complete, accurate rows without over-granting tenant-wide access.

Pre-payroll time audits fail most often because “missing hours” in Workday span four distinct object states: workers who entered zero time blocks (`workersWithNoTimeBlocks`), workers who clocked in without clocking out (`incompleteTimeBlocks`), workers who saved draft hours without clicking Submit (`isSubmitted = false`), and submitted entries sitting in a manager’s or project lead’s approval queue (`isSubmitted = true AND isApproved = false`). Treating all four states as a single status filter causes silent payroll underpayments and missed client billing cutoffs.

## Which WQL Data Source Matches Each Missing-Time Scenario?

Before writing a WQL statement or exposing a Reports-as-a-Service (RaaS) endpoint, map each pre-cutoff exception to the Workday data source that actually surfaces it:

| Pre-Payroll Exception | WQL Data Source Alias | Primary Business Object | `filterIsRequired` | Key Status & Quantity Fields |
| --- | --- | --- | --- | --- |
| Saved draft time blocks (not yet submitted) | `allTimeBlocks` | `Time Block` | `true` | `isSubmitted`, `isApproved`, `timeBlockStatus`, `reportedQuantity`, `reportedDate` |
| Submitted time blocks awaiting approval | `allTimeBlocks` | `Time Block` | `true` | `isSubmitted`, `isApproved`, `approvalDate`, `totalHoursTimeTracking`, `projectForWorkerTimeBlock` |
| Project timesheet lines in draft, submitted, or sent-back state | `projectTimesheetLinesForWorkersWithinDateRange` | `Project Timesheet Line` | `false` (built-in prompts) | `timesheetStatus`, `timesheetIsApproved`, `totalHoursInDateRange`, `totalHoursBillable` |
| Clock-in punches missing an out time | `incompleteTimeBlocks` | `Incomplete Time Block` | `true` | `timeBlockStatus`, `reportedDate`, `startDate`, `projectForWorkerTimeBlock` |
| Eligible workers with zero entries in period | `workersWithNoTimeBlocks` | `Worker` | `false` (org & date prompts) | Worker reference rows for follow-up reminders |

For general WQL syntax rules and REST pagination mechanics, see [Workday WQL fundamentals](https://kiweely.com/guides/workday-wql) and [choosing between RaaS, WQL, and REST](https://kiweely.com/guides/workday-raas-wql-rest).

## Querying Unsubmitted and Unapproved Time Blocks on `allTimeBlocks`

The `allTimeBlocks` data source covers both reported and calculated time blocks, so Workday marks `filterIsRequired` as `true` to prevent unbounded full-tenant scans. Calling `SELECT ... FROM allTimeBlocks` without a `dataSourceFilter` fails validation immediately. Worse, picking the wrong filter hides unsubmitted drafts altogether—for example, `myTeamsReportedTimeBlocks` explicitly filters *only* for reported time blocks that are already **Submitted** or **Approved**.

Compare that trap against a period-scoped filter that retains draft entries:

Fails

```
-- Fails two ways:
-- 1. Omitting dataSourceFilter on allTimeBlocks triggers a required-filter error.
-- 2. Switching to myTeamsReportedTimeBlocks silently excludes unsubmitted draft blocks!
SELECT
  worker2,
  reportedDate,
  reportedQuantity,
  isSubmitted,
  isApproved
FROM allTimeBlocks(
  dataSourceFilter = myTeamsReportedTimeBlocks,
  organizations = ('817bbf12d6c710000fc644a491ae0015'),
  startDate = '2026-11-01',
  endDate = '2026-11-14'
)
WHERE isSubmitted = false
```

Works

```
-- Uses reportedTimeBlocksForWorkersByPeriod or timeBlocksSecuredBySupervisoryOrganization
-- so unsubmitted (isSubmitted = false) and unapproved (isApproved = false) blocks both appear:
SELECT
  worker2,
  supervisoryOrgForWorkerTime,
  reportedDate,
  timeEntryCode,
  projectForWorkerTimeBlock,
  reportedQuantity,
  isSubmitted,
  isApproved,
  timeBlockStatus
FROM allTimeBlocks(
  dataSourceFilter = timeBlocksSecuredBySupervisoryOrganization
)
WHERE reportedDate >= '2026-11-01'
  AND reportedDate <= '2026-11-14'
  AND isReportedTimeBlock = true
  AND (isSubmitted = false OR isApproved = false)
ORDER BY supervisoryOrgForWorkerTime ASC, worker2 ASC, reportedDate ASC
```

When auditing by Cost Center or Location rather than Supervisory Organization, swap the filter to `allTimeBlocksForWorkersByCostCenter` (supplying `costCenter`, `startDate`, and `endDate`) or `allTimeBlocksForWorkersByLocation`. Always include `isReportedTimeBlock = true` when chasing unsubmitted worker entries so you do not double-count paired calculated rows.

## Catching Unsubmitted Project Hours and Cross-Org Security Traps

Project time tracking introduces two classic pitfalls in Workday: **filter status blind spots** and **cross-supervisory security constraints**.

First, examine how Workday’s project filter on `allTimeBlocks` behaves. The `reportedTimeBlocksForProjectsProjectHierarchies` filter requires `projectsAndProjectHierarchies` (and accepts `startDate`, `endDate`, `workers`, and `includeSubordinateProjectHierarchies`), and it surfaces **submitted, sent-back, and approved** time blocks for project workers. That makes it ideal for finding **unapproved** (`isApproved = false`) or **sent-back** project blocks before billing close, whereas completely untouched **unsubmitted** project timesheet lines should be queried from `projectTimesheetLinesForWorkersWithinDateRange` (which returns project timesheet lines in **any status**):

Works

```
SELECT
  workerForTimesheetLine,
  supervisoryOrganizationForWorker,
  project_worktag,
  timesheetPeriod,
  timesheetStatus,
  timesheetIsApproved,
  timesheetLineIsBillable,
  totalHoursInDateRange
FROM projectTimesheetLinesForWorkersWithinDateRange(
  startDate = '2026-11-01',
  endDate = '2026-11-14'
)
WHERE timesheetIsApproved = false
ORDER BY project_worktag ASC, workerForTimesheetLine ASC
```

Second, verify why a Project Manager often gets zero rows for matrixed engineers or consultants outside their own Supervisory Organization:

1.  **Missing Project Role Assignment:** The reviewer must hold an assigned role on the project or project hierarchy via **Assign Roles to Projects** (secured to *Manage: Project Details* in the Project Tracking functional area).
2.  **Missing Cross-Org Domain Permissions:** To report on project time across supervisory boundaries, grant a [constrained role-based security group](https://kiweely.com/guides/workday-constrained-vs-unconstrained-security-groups) access to both **`Reports: Time Tracking`** (Time Tracking functional area) and **`Manage: Project Plan`** (Project Tracking functional area), then run **Activate Pending Security Policy Changes**.
3.  **Accidental Unconstrained Leakage:** Never grant *unconstrained* access to `Manage: Project Plan` to ordinary project leads. Workday documents that unconstrained access on `Manage: Project Plan` exposes *all* time blocks across the entire enterprise. Keep the role-based group constrained to the project/project hierarchy, and apply `reportedTimeBlocksForProjectsProjectHierarchies` so managers only see projects they own.
4.  **Indexed Report Fields Blocking Cross-Org Rows:** If you wrap your query in a custom RaaS report instead of raw WQL, remove any **indexed report fields** from your Custom Report Filter and Group By sections. Indexed worker/supervisory fields force Workday to intersect results with the viewer’s Supervisory Organization, silently dropping matrixed project contributors.

Catching Open Clock-Ins Before Payroll Calculation

Workers using web clocks or mobile check-in with optional out times create **Incomplete Time Blocks** whenever they forget to clock out. Workday excludes incomplete blocks from time calculations, so `calculatedQuantity` is zero even though the employee worked a full shift. Always pair your `allTimeBlocks` check with a query against `incompleteTimeBlocks(dataSourceFilter = incompleteTimeBlocksInDateRangeSecuredToSupervisoryOrganization, startDate = '...', endDate = '...')` before locking payroll.

## Calling WQL Over REST and Handling Post-Cutoff Approvals

Execute your pre-payroll WQL query via `GET /wql/v1/data` (for queries under 2,048 characters) or `POST /wql/v1/data` (for queries up to 16,000 characters, such as multi-organization `IN` lists). Remember to append `offset=0` if you need to bypass Workday’s 30-minute WQL result cache during the final hour before payroll lock:

http

```
POST /ccx/api/wql/v1/{tenant}/data?limit=1000&offset=0 HTTP/1.1
Content-Type: application/json

{
  "query": "SELECT worker2, reportedDate, projectForWorkerTimeBlock, startDate FROM incompleteTimeBlocks(dataSourceFilter = incompleteTimeBlocksInDateRangeSecuredToSupervisoryOrganization, startDate = '2026-11-01', endDate = '2026-11-14')"
}
```

To use WQL externally, ensure the caller holds View access to the **Workday Query Language** domain in the *System* functional area alongside *Reports: Time Tracking*. And if a manager approves late time entries *after* an initial pay calculation has already run for the period, run **Run Pay Calculation** with **Smart Calculation** or **Smart Calculation Based on Events** so those newly approved blocks flow into the open payroll result rather than stranding until next period’s retro run (see [troubleshooting Time Tracking retro recalculations](https://kiweely.com/guides/workday-time-tracking-absence-retro-recalculation-errors)).

## Pre-Cutoff Verification Checklist

Run these four checks in Sandbox before relying on an automated missing-time query in Production:

1.  **Test all four states with synthetic entries:** Stage one worker with zero entries, one with an open clock-in (`incompleteTimeBlocks`), one with saved unsubmitted hours (`isSubmitted = false`), and one awaiting approval (`isSubmitted = true AND isApproved = false`), and confirm your queries surface all four.
2.  **Proxy or sign in as a constrained Project Manager:** Confirm the manager sees project time blocks for a worker in a sibling Supervisory Organization, and confirm they *cannot* see blocks on an unrelated project (`Manage: Project Plan` constrained, not unconstrained).
3.  **Verify Worked Hours Calculation Tags:** If cross-checking WQL sums against Workday’s delivered **Review Time** or **Review Project Time** reports, inspect **Edit Time Approval Template** and **Edit Project Time Approval Settings** to ensure your WQL `calculationTags` filter matches the exact tags driving the delivered *Unsubmitted Time* and *Submitted Time* columns.
4.  **Bypass stale WQL cache near cutoff:** Pass `offset=0` on live cutoff-morning refreshes so blocks submitted five minutes ago do not still show as unsubmitted from a cached WQL page.

If you want managers and project leads to ask for unsubmitted team or project hours directly in Claude, ChatGPT, or Gemini under their own constrained Workday security—or view a clean pre-cutoff coverage grid in the browser or Microsoft Teams—[Kiweely Bridge](https://kiweely.com/bridge) and [Kiweely Leaf](https://kiweely.com/leaf) (both coming next) run live WQL and RaaS queries as the signed-in user with zero employee data stored outside Workday, while [Kiweely Vine](https://kiweely.com/vine) builds and tests custom WQL and RaaS definitions directly against your tenant today.

## Frequently asked questions

### Why does my WQL query on allTimeBlocks fail without a dataSourceFilter?

In Workday, the All Time Blocks report data source (allTimeBlocks) enforces filterIsRequired as true. You must supply a valid dataSourceFilter alias inside the FROM clause, such as allTimeBlocksCreatedBetweenADateRange or timeBlocksSecuredBySupervisoryOrganization, along with its required date or organization parameters.

### Why are open clock-ins missing from unsubmitted hours totals?

When a worker checks in without recording an out time, Workday creates an Incomplete Time Block and excludes it from standard time calculations until an out time is entered. Query the incompleteTimeBlocks data source separately before payroll cutoff to catch open punches.

### Why cannot a Project Manager see project time blocks for workers outside their supervisory organization?

Project managers need an assignable role on the project plus access to both Reports: Time Tracking and Manage: Project Plan domains, and the query or custom report must use a project data source filter such as reportedTimeBlocksForProjectsProjectHierarchies without indexed supervisory report fields blocking cross-org rows.

### Does reportedTimeBlocksForProjectsProjectHierarchies return unsubmitted draft time blocks?

No. That specific filter on allTimeBlocks only returns existing time blocks that were approved, sent back, or submitted in the date range. To catch unsubmitted project hours across all statuses, query projectTimesheetLinesForWorkersWithinDateRange or filter allTimeBlocks by supervisory, cost center, or period filters where isSubmitted is false.

## Sources checked

-   [Troubleshooting: Project Time Blocks on Reports](https://doc.workday.com/admin-guide/en-us/human-capital-management/time-tracking/reviewing-and-approving-time/troubleshooting--project-time-reporting.html)
-   [Steps: Report on Time Across Supervisory Organizations](https://doc.workday.com/admin-guide/en-us/human-capital-management/time-tracking/reviewing-and-approving-time/mlq1487710930080.html)
-   [Concept: Incomplete Time Blocks](https://doc.workday.com/admin-guide/en-us/human-capital-management/time-tracking/time-entry-validations/gnt1518718620488.html)
-   [Set Up the Review Project Time Report](https://doc.workday.com/admin-guide/en-us/human-capital-management/time-tracking/reviewing-and-approving-time/oek1550616029209.html)
-   [Reference: WQL REST API](https://doc.workday.com/admin-guide/en-us/reporting-and-analytics/custom-reports-and-analytics/workday-query-language-wql-/srr1614364076622.html)

## Related guides

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

-   [### Why Workday Absence Balances or Time Calculations Don’t Update After a Retro Job Change Workday keeps prior stored absence balances when a retroactive job change precedes the last stored balance date, and it skips automatic time recalculations after eligibility changes. Run Recalculate Worker Time Off Balances and Run Time Calculations for a Date Range to update both.](https://kiweely.com/guides/workday-time-tracking-absence-retro-recalculation-errors)
-   [### Constrained vs unconstrained security groups in Workday: which workers can a member see? An unconstrained group gives members access to every worker in the tenant for the secured item. A constrained group limits them to the organizations they are assigned to, such as an HR Partner for one supervisory organization.](https://kiweely.com/guides/workday-constrained-vs-unconstrained-security-groups)
-   [### Should I use RaaS, WQL or the REST API to extract data from Workday? Use RaaS for a saved report’s output, WQL for a filtered, grouped or paged extract of up to 1 million rows, and REST for small, low-latency reads of one resource. Limits and sources are in the table.](https://kiweely.com/guides/workday-raas-wql-rest)
-   [### What is Workday Query Language (WQL), and how do you write and run a query? Workday Query Language (WQL) is Workday’s SQL-like language for reading data from data sources and fields instead of reports. You need the Workday Query Language domain in the System functional area; an external caller also needs an API client with System scope.](https://kiweely.com/guides/workday-wql)

### More guides on WQL

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

-   [Querying Pending Workday My Tasks and Inbox Approvals via API and WQL](https://kiweely.com/guides/workday-inbox-my-tasks-awaiting-action-rest-wql)
-   [Why fileLength on workerDocuments Returns 52 in WQL for Business Process Attachments](https://kiweely.com/guides/wql-workerdocuments-filelength-returns-52)
-   [Paging with POST /wql/v1/data in a PMD Grid When Queries Exceed URL Limits](https://kiweely.com/guides/wql-post-data-endpoint-grid-pagination-url-limit)
-   [Escaping Single Quotes for Multi-Value IN Clauses and Fixing Double URL-Encoded Unicode in PMD WQL](https://kiweely.com/guides/wql-pmd-single-quote-escaping-double-urlencoded-unicode)
-   [Filtering WQL Queries by Organization Hierarchy and workersByRole Without Throwing Security Errors](https://kiweely.com/guides/wql-organization-hierarchy-filter-workersbyrole)
-   [Why WQL Queries on findCandidates and allWorkers Return Empty Right After a Business Process Step](https://kiweely.com/guides/wql-indexing-delay-findcandidates-bp-status-change)
-   [Fixing WQL Error 804 on GROUP BY and Related Business Object Aggregation Limits](https://kiweely.com/guides/wql-group-by-error-804-rbo-aggregation-limits)
-   [Fixing WQL Error “Empty Required Parm Moment\_Parm” with SUM()](https://kiweely.com/guides/wql-empty-required-parm-moment-parm-sum)

### From the blog on WQL

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

-   [What happens after ChatGPT writes your WQL query](https://kiweely.com/blog/after-chatgpt-writes-your-wql)
-   [Answering Executive Span-of-Control and Headcount Questions Live from Workday](https://kiweely.com/blog/executive-org-span-of-control-attrition-questions-live-workday)
-   [Build vs. Buy a Workday MCP Server: OAuth 2.1, SOAP, WQL, and Twice-Yearly Releases](https://kiweely.com/blog/build-vs-buy-workday-mcp-server-engineering-cost)

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