---
title: "Build vs. Buy a Workday MCP Server: Engineering Cost"
description: "What engineering teams actually build and maintain for an in-house Workday MCP server: OAuth 2.1 + PKCE sealing, WQL discovery, SOAP pagination, RaaS, and…"
url: https://kiweely.com/blog/build-vs-buy-workday-mcp-server-engineering-cost
---

# Build vs. Buy a Workday MCP Server: OAuth 2.1, SOAP, WQL, and Twice-Yearly Releases

Wrapping GET /workers in a weekend script takes hours, but a company-wide Workday MCP server requires remote OAuth 2.1 brokering, Workday PKCE token sealing, WQL schema discovery, SOAP XML pagination, RaaS parsing, browser write checks, and twice-yearly release updates.

-   By Kiweely
-   November 15
-   7 min read

Any competent backend engineer can wire Anthropic’s or OpenAI’s Model Context Protocol (MCP) SDK to Workday’s `GET /common/v1/workers` endpoint with a static Sandbox token in a single afternoon. Shipping a production **company-wide Workday MCP server**—safe for every employee across Claude, ChatGPT, and Gemini on web, desktop, and mobile—is a completely different engineering project spanning **remote MCP OAuth 2.1 brokering, Workday PKCE token rotation, dynamic WQL schema discovery, SOAP XML snapshot pagination, RaaS prompt marshaling, out-of-band write approvals, and twice-yearly Workday R1/R2 release upkeep**.

Before assigning two platform engineers and an HRIS architect to build an internal Workday MCP server, review the seven subsystems your team will actually write, security-review, and carry on pager rotation.

## Prototype vs. Production: The Real Engineering Scope

| Subsystem | Afternoon Prototype (1 Dev) | Company-Wide Production Requirement |
| --- | --- | --- |
|  **Transport & rollout** | Local `stdio` script on one MacBook | Public HTTPS remote MCP server supporting Claude, ChatGPT, and Gemini across web, desktop, iOS, and Android |
|  **Authentication** | Hardcoded `ISU_*` refresh token in `.env` | Full **MCP OAuth 2.1 Authorization Server** bridging to Workday `Register API Client` (**Authorization Code + PKCE**) per employee |
|  **Token storage & rotation** | Plaintext JSON file or Redis cache | Cryptographic client-sealed grants (AES-256-GCM) + atomic handling of Workday’s rotating `refresh_token` and non-sliding expiry |
|  **Workday data surfaces** | 3–5 hardcoded REST `GET` endpoints | REST + dynamic **WQL** (`/dataSources` discovery, `GET`/`POST /data` switching) + **SOAP XML** (`Bearer` auth) + **Custom RaaS** |
|  **Pagination & limits** | First 20 rows only | WQL 30-minute session cache (`limit`/`offset` up to 10k) + SOAP `Response_Filter` (`As_Of_Entry_DateTime` & `As_Of_Effective_Date`) |
|  **PII & write safety** | Raw JSON dumped to LLM and stdout logs | Schema-locked zero-body logging, RAM field redaction, and **out-of-band browser approval** (*Now* vs. *After*) for writes |
|  **Ongoing maintenance** | None until demo ends | Weekly Sandbox refresh URL routing + twice-yearly **Workday R1/R2** WSDL, WQL alias, and security regression testing |

## 1\. Bridging MCP OAuth 2.1 to Workday’s PKCE Quirks

Remote MCP clients (Claude Enterprise/Team, ChatGPT Enterprise/Team, Gemini) authenticate against remote tool servers using the **MCP OAuth 2.1 specification** (including Protected Resource Metadata, Dynamic Client Registration or pre-registered workspace credentials, and `S256` PKCE). Workday’s OAuth 2.0 server (`/{tenant}/authorize` and `/ccx/oauth2/{tenant}/token`) does **not** implement MCP OAuth 2.1 metadata discovery natively, and exhibits three Workday-specific behaviors your OAuth broker must handle:

1.  **Custom Basic header formatting on confidential/PKCE exchanges:** Workday’s token endpoint documentation specifies `Authorization: Basic ID <Base64>` or form-encoded `client_id` + `code_verifier` depending on how the client was registered in **Register API Client** vs. the Developer Site Console (see [PKCE OAuth setup with corporate SSO](https://kiweely.com/guides/workday-api-client-pkce-sso-without-workday-password)).
2.  **Rotating refresh tokens with a fixed wall-clock horizon:** Every `grant_type=refresh_token` POST returns *both* a new `access_token` and a new `refresh_token`. Concurrent tool calls from an LLM (which routinely fires 4 parallel MCP `tools/call` requests in one turn) will race on refresh rotation unless you implement per-user single-flight locking—and because Workday’s **Refresh Token Timeout (in days)** never slides forward on refresh, your server must cleanly trigger a fresh OAuth challenge when the original authorization horizon expires.
3.  **Eliminating the token database honeypot:** If your internal server stores 5,000 employee refresh tokens—including your CHRO’s and CFO’s—in Postgres or Redis, your MCP service immediately becomes a Tier-0 HR credential vault requiring encryption key rotation, SOC/SOX audit controls, and intrusion monitoring.

## 2\. REST Covers Less Than You Think: WQL, SOAP, and RaaS

Teams that start against the Workday REST API Explorer hit coverage walls within week one (detailed in [when to use RaaS, WQL, or REST](https://kiweely.com/guides/workday-raas-wql-rest)):

-   **Live WQL (`/wql/v1/data`)** is required for analytical questions, aggregations, and custom object joins. Because every Workday tenant has thousands of tenanted calculated fields (`cf_*`) with tenant-specific aliases, an LLM cannot guess WQL syntax from pre-training—it will hallucinate field names and trigger 400 errors. Your MCP server must dynamically query `GET /wql/v1/dataSources` and `GET /wql/v1/dataSources/{ID}/fields`, switch automatically from `GET /data?query=...` (capped at **2,048 characters**) to `POST /data` (up to **16,000 characters**), and manage WQL’s 30-minute user-session pagination cache (see [paginating WQL past 500 rows](https://kiweely.com/guides/wql-more-than-500-rows)).
-   **Workday SOAP Web Services (`urn:com.workday/bsvc`)** still own huge swaths of Benefits, Compensation, Payroll, Financial Management, and Recruiting. Calling SOAP on behalf of an SSO employee requires HTTP `Authorization: Bearer` headers, stripping WS-Security headers, parsing `HTTP 500` `<SOAP-ENV:Fault>` envelopes, and pinning **both** `As_Of_Effective_Date` and `As_Of_Entry_DateTime` inside `<bsvc:Response_Filter>`—otherwise page 2 defaults to `now()` in the user’s or server’s timezone and duplicates or drops worker rows:

xml

```
<bsvc:Response_Filter>
  <bsvc:As_Of_Effective_Date>2026-11-15</bsvc:As_Of_Effective_Date>
  <bsvc:As_Of_Entry_DateTime>2026-11-15T19:30:00Z</bsvc:As_Of_Entry_DateTime>
  <bsvc:Page>2</bsvc:Page>
  <bsvc:Count>100</bsvc:Count>
</bsvc:Response_Filter>
```

-   **Custom Reports-as-a-Service (RaaS)** hold the exact definitions your HRIS and Finance teams already trust (`urn:com.workday.report/...`). Your MCP server has to parse required report prompts, handle `backslash` owner-name edge cases, and normalize deeply nested `wd:Report_Entry` JSON/XML structures without blowing out the LLM’s context window.

## 3\. Field Redaction, Zero-Body Observability, and Prompt-Injection Write Defense

Standard APM and logging middleware (`pino`, `winston`, OpenTelemetry HTTP auto-instrumentation, API gateway access logs) log query strings, tool arguments, or exception bodies by default. On Workday traffic, one uncaught JSON parse exception dumps worker names, SSNs, or base pay straight into Datadog or CloudWatch. You must write a schema-locked telemetry layer that strips all bodies before serialization.

If management asks to enable even a single write action—such as `Request Time Off` or updating contact details—relying on the LLM’s system prompt (*“Always ask the user before calling `submit_time_off`”*) fails basic application security review. Indirect prompt injection inside an email or resume read in the same chat session can instruct the model to invoke the write tool directly. Preventing that requires building an **out-of-band state machine**: holding a pending action hash, serving a separate browser confirmation UI showing *Now* vs. *After* values fetched from Workday, authenticating the human click, and resuming the transaction.

## 4\. Twice-Yearly Workday Releases (R1 & R2) and Sandbox Refreshes

Building v1.0 is only the down payment. Every Workday customer receives:

-   **Weekly service updates and weekly Sandbox refreshes:** Every weekend, Sandbox is overwritten by Production, wiping Sandbox-only API Client tests unless you build multi-tenant configuration management across Implementation, Sandbox, Sandbox Preview, and Production.
-   **Twice-yearly Feature Releases (March R1 and September R2):** Workday delivers preview changes to **Sandbox Preview** five weeks before Production cutover, retires end-of-life WWS SOAP versions (`Request service version has reached its end of life`), alters WQL data source filters, and introduces new Business Process validation rules (see our [Workday release preparation audit checklist](https://kiweely.com/guides/workday-release-preparation-audit-checklist)). Your internal engineers now own semi-annual Workday regression cycles forever.

## The Math: In-House Build Cost vs. Kiweely Bridge

Even a conservative engineering estimate makes the TCO gap stark:

-   **Initial build (6–10 weeks across 1 senior backend engineer + 0.5 InfoSec/HRIS architect):** ~$45,000–$80,000 in loaded engineering time before a single employee uses it.
-   **Ongoing maintenance (cloud hosting, OAuth/TLS on-call, new RaaS/WQL requests, R1 & R2 release testing — ~15% FTE/year):** ~$25,000–$35,000 every year.

Compare that with **[Kiweely Bridge](https://kiweely.com/bridge)** (**coming next**; see [Bridge compare](https://kiweely.com/bridge/compare) and [Bridge security](https://kiweely.com/bridge/security)):

1.  **All seven subsystems built, tested, and maintained for Workday:** Remote MCP across **Claude, ChatGPT, and Gemini** on Mac, Windows, web, and phone; `Register API Client` + PKCE user-delegated OAuth (never an ISU); out-of-the-box REST, live WQL discovery, SOAP reads, and custom RaaS; plus an **AI admin agent** that sets up Functional Areas in Sandbox, applies RAM field redaction, and tests real roles (`Employee`, `Manager`, `HR Partner`).
2.  **Zero stored payloads + out-of-band browser write cards:** Employee Workday tokens are sealed with **AES-256-GCM** inside the MCP client token (zero token database), responses stream through RAM with schema-locked body-free telemetry, and enabled writes pause for a browser card showing *Now* vs. *After*.
3.  **Need VPC control? Self-host the container without writing the code:** If your reason for building in-house is keeping Workday traffic 100% inside your own cloud perimeter, Kiweely Bridge ships as a **signed, stateless self-hosted container** for AWS ECS, Google Cloud Run, Azure Container Apps, or Kubernetes (alongside **Kiweely Cloud** and **Dedicated single-tenant** static IP for Workday `Maintain IP Ranges`).
4.  **Flat company pricing from $499/mo ($5,988/yr):**
    -   **Up to 1,000 Workday employees:** **$499 / month**
    -   **1,001 to 5,000 employees:** **$1,499 / month**
    -   **5,001 to 20,000 employees:** **$3,999 / month**
    -   **Over 20,000 employees** or Dedicated / Self-Hosted container: **Enterprise by quote**
    -   **One person on their own Workday developer tenant:** **Free** (no trial, no card)
    -   Every plan includes **unlimited calls**, **Production + all Sandbox and implementation tenants**, and automatic twice-yearly Workday release updates.

*(And if your engineering backlog also has tickets to build custom employee portals, manager views, or mobile/Teams approval screens on top of Workday APIs, [Kiweely Leaf](https://kiweely.com/leaf)—also coming next—lets HRIS admins describe and publish stateless pass-through Workday UIs in plain English without an Extend license or an internal frontend build. For consultants and developers building inside Workday Extend and Studio right now, [Kiweely Vine](https://kiweely.com/vine) is live today.)*

## Frequently asked questions

### Why can't we just ship a local stdio Python or Node MCP script to employees?

Local stdio MCP servers (.mcpb bundles or CLI scripts) only run on desktop laptops where Python or Node is installed and managed via MDM—they cannot run on Claude, ChatGPT, or Gemini in web browsers, on iPhones, or on Android devices. Worse, shipping client secrets onto employee laptops breaks OAuth confidentiality, and pushing emergency patches when Workday updates schemas requires an MDM rollout across thousands of machines.

### Why isn't wrapping Workday's REST API enough for an internal MCP server?

Workday's REST API covers a narrow slice of self-service and staffing objects. Analytical rollups require WQL (/wql/v1/data), business-specific calculated fields live inside custom Reports-as-a-Service (RaaS), and broad sections of Benefits, Payroll, Financials, and Recruiting are only reachable via Workday Public Web Services (SOAP XML).

### What breaks on an in-house Workday MCP server during March (R1) and September (R2) releases?

Twice a year, Workday retires older SOAP WWS versions, changes WQL field and data source aliases, updates required Business Process prompts, and refreshes Sandbox Preview five weeks ahead of Production. An internal engineering team has to regression-test every tool against Sandbox Preview twice a year or face broken employee tools on release weekend.

### Can we self-host Kiweely Bridge inside our own cloud VPC instead of building from scratch?

Yes. Kiweely Bridge (coming next) offers a signed, stateless self-hosted container deployment for AWS ECS, Google Cloud Run, Azure Container Apps, or Kubernetes alongside Kiweely Cloud ($499–$3,999/mo by employee count) and Dedicated static-IP hosting—giving your security team zero external network hop without writing or maintaining the Workday protocol stack.

## Read next

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

-   [September 21 ### What happens after ChatGPT writes your WQL query](https://kiweely.com/blog/after-chatgpt-writes-your-wql)
-   [November 15 ### Answering Executive Span-of-Control and Headcount Questions Live from Workday](https://kiweely.com/blog/executive-org-span-of-control-attrition-questions-live-workday)
-   [November 19 ### Kiweely builds, deploys and runs a Workday Studio integration from one request](https://kiweely.com/blog/workday-studio-integration-built-deployed-and-run)

### More guides on WQL

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

-   [Fixing WQL “Cannot construct instance source on grouped results” with COUNT(DISTINCT)](https://kiweely.com/guides/wql-count-distinct-with-where-on-rbo-filter)
-   [Why WHERE fieldA = fieldB Throws “Invalid Where Clause” in WQL](https://kiweely.com/guides/wql-compare-two-fields-where-clause-invalid)
-   [Filtering Empty Related Business Objects in WQL and Guarding Omitted RBO Keys in PMD](https://kiweely.com/guides/wql-check-rbo-empty-missing-json-keys-pmd)
-   [Fixing WQL “Specify a valid report field” and HTTP 500 Errors When an ISU Queries Calculated Fields](https://kiweely.com/guides/wql-calculated-field-isu-specify-valid-report-field-500)
-   [Why WQL AVG() Rounds to Whole Numbers and How to Handle Conditional Logic Without CASE](https://kiweely.com/guides/wql-avg-integer-rounding-conditional-logic-without-case)
-   [WQL 500-Instance Related Business Object Limit and Large IN (...) Filter Limits](https://kiweely.com/guides/wql-500-rbo-instances-per-row-large-in-filter-limits)
-   [Fixing WQL HTTP 400 “Parms are required for the fields or data source in the query”](https://kiweely.com/guides/wql-400-parms-are-required-for-fields-or-data-source)
-   [Custom Agent Actions that call Workday SOAP, REST and WQL](https://kiweely.com/guides/workday-custom-agent-actions-soap-rest-wql)

## Your Workday work, done by AI.

Kiweely Vine is the AI agent that builds, deploys and tests Extend apps as real people, makes changes in any Workday task screen, answers from your real tenant and builds reports.

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

## Get the next one in your inbox.

One email a month for Workday teams: what’s changing in Workday and what to retest, one tip tried in a real tenant, and what’s new at Kiweely.
