Major

Automate Greenhouse-to-Workday New-Hire Handoffs

Turn a Greenhouse hire into a verified Workday handoff. Design the field checks, approval gate, and durable audit trail that keep HR onboarding from re-keying the same data twice.

Ritvij Gautam
Automate Greenhouse-to-Workday New-Hire Handoffs

TL;DR: what you'll build. HR onboarding teams still re-key a new hire's role, compensation band, and start date from Greenhouse into Workday by hand, usually the same week the person is supposed to show up for day one. This article shows how to build a Major app that watches Greenhouse for the candidate-hired event, validates every field Workday's Hire Link process needs, and routes anything incomplete or duplicate to HR for a one-click approval before the documented Workday hire process runs. You end up with an audit trail of every hire handoff, not a spreadsheet of exceptions nobody remembers.

The HR handoff problem and who owns it

HR onboarding operations owns this process, and the point where it breaks is the week between an offer and a start date. A recruiter marks a candidate hired in Greenhouse. Somebody on the HR team then opens Workday and manually types the role, compensation band, department, and start date into a new worker record, hoping they copied the offer letter correctly.

That manual step is where things go wrong. A typo in the compensation band means payroll runs with the wrong number in week one. A missed supervisory organization field means the new hire has no manager to report to in the system on day one. A forgotten rehire flag means Workday creates a duplicate record instead of reactivating the old one.

This is the same operational pattern covered in Major's broader guide to AI agents for HR: a repeatable cross-system handoff that depends on a person noticing every required field, every time, under time pressure. It also sits next to the recruiting side of the funnel described in AI agents for recruiting, since the trigger starts inside the applicant tracking system.

The fix is not to let an AI model write directly into Workday. It is a Major app that holds the state of every hire in flight, a workflow that runs deterministic checks the same way every time, and an agent that only steps in to explain what is missing or ambiguous. Major's underlying principle is reason once, run forever: a person or an agent figures out the mapping logic once, and after that the app runs it on every hire without re-deriving the rules from scratch.

What actually triggers a Greenhouse-to-Workday hire

A plain accepted offer in Greenhouse does not create a Workday worker. That is a common misconception worth correcting up front, because it changes where you put your trigger.

Greenhouse's own support documentation on Hire Link for Workday states that the export to Workday runs when the candidate is marked as hired, which happens after the offer has already been accepted and processed through Greenhouse's internal hiring steps. Workday then attempts to create a pre-hire profile and start its own new-hire process on the other side. An accepted offer is a precondition, not the trigger itself.

Hire Link supports three hire types: New Hire, Rehire, and Transfer. Setup requires a Greenhouse account manager to enable the HRIS Link for Workday add-on (or the Hire Link-only add-on), a Harvest API key configured with the HRIS Link partner option, Workday Integration System User credentials, and an Integration Admin who has already chosen the organization's staffing model in Workday. Contingent-worker business processes are explicitly not supported by Hire Link.

The staffing model matters because it changes which field is required. In Position Management mode, the hire needs an Opening ID. In Job Management mode, it needs a Supervisory Organization instead. In Hybrid mode, Greenhouse routes the hire as position-based when the Supervisory Organization is blank, and as job-based (dropping the Opening ID from the transfer) when it is populated.

Some organizations skip Hire Link entirely and build their own middleware instead. Greenhouse documents this pattern as just-in-time position export: a hire fires the candidate_hired webhook, middleware (commonly Workday Studio) receives the event, creates the position in the HRIS, then sends candidate, application, and offer details to create the hire record. This is a real pattern, not a hypothetical, but it is still the organization's own middleware doing the Workday write, not a generic public Workday endpoint.

Either way, the signal a Major app should watch is the hire event, not the offer-accepted event. Think of offer-accepted as someone saying yes to a job and marked-hired as HR actually processing the paperwork to start them. The first is a conversation; the second is the administrative act that downstream systems react to.

The systems involved

Greenhouse Harvest API

Greenhouse exposes recruiting data through the Harvest API v3, a REST API authenticated with a bearer token (API key) or OAuth 2.0 for partner integrations with scopes like harvest:offers:list and harvest:candidates:list.

The objects this process needs:

  • Offers, GET /v3/offers returns offer records with a status field (Created, Accepted, Rejected, Deprecated), resolved_at, sent_on, and starts_on dates. You can filter by status=Accepted paired with a resolved_at range to find recently resolved offers.
  • Candidates, GET /v3/candidates returns identity, contact details, company, title, and custom fields.
  • Applications, GET /v3/applications links a candidate to a job and tracks their stage history.

Both endpoints paginate with a per_page parameter (1 to 500, default 100) and a cursor-based page token taken from the response header for subsequent pages. Greenhouse's published docs do not list a specific numeric rate limit, so your workflow should still back off on 429 responses rather than assuming none will occur.

For event-driven triggers, Greenhouse's webhook system fires a candidate_hired (action hire_candidate) event when the offer is accepted on the candidate's Private tab. The payload carries the application, candidate, job, and offer objects. Greenhouse signs the entire request body with HMAC-SHA256 using a secret you set when registering the webhook, delivered in a Signature header alongside a Greenhouse-Event-ID header for idempotency.

A webhook is like a doorbell: Greenhouse rings your endpoint the moment someone is marked hired, so your app does not have to keep knocking on Greenhouse's door every few minutes asking whether anyone is hired yet.

Workday HCM

Workday's REST API documentation covers retrieval and transactional workflows for Extend and Integration applications, authenticated through a licensed tenant with Integration System User credentials (OAuth 2.0 client credentials or authorization code, depending on the integration type).

The public Workers reference documents GET /workers for a collection and GET /workers/{id} for a single worker. It covers retrieval fields like businessTitle, primarySupervisoryOrganization, and primaryWorkEmail. It does not document a create operation. If your plan assumes a generic POST /workers call will create a new hire, stop: that endpoint is not in the published reference.

Workday's Business Process REST APIs describe initiating Workday-delivered business processes (the docs give job-change and one-time-payment examples), then managing event status, steps, approvals, and cancellations. They do not spell out a universal hire-process endpoint or its authentication flow in the public reference. In practice, hire initiation runs through either the Greenhouse Hire Link integration described above or a tenant-specific configuration your Workday admin sets up with their implementation partner.

This is the honest boundary this whole article respects: Major does not call an undocumented Workday hire endpoint. It builds the readiness and validation layer around whichever path your organization has already enabled, Hire Link or a tenant-configured process, and it tracks the outcome.

Regulation and data minimization

This handoff touches identity and compensation data, but it is not a screening or selection decision, so most hiring-AI regulation does not apply directly. The one that matters is scope, not an obligation to meet.

The EEOC's guidance on employment tests and selection procedures, which covers Title VII adverse-impact analysis for software and algorithm-assisted selection tools, concerns tools that screen, rank, or score candidates, which creates Title VII exposure if they produce disparate impact. This build does not do that. The agent in this workflow never ranks candidates or decides who gets hired. Its only job is mapping already-decided offer data to Workday fields and flagging gaps. Keep it that way deliberately: never let this app's agent touch rejection reasons, scorecards, or stage-advancement logic, because that would pull it into EEOC's scope.

The practical control that does matter here is data minimization. Compensation band and legal name are sensitive. Limit who can view them in the Major app to HR onboarding and HRIS admin roles, and keep the Workday integration account scoped to only the staffing and worker-creation permissions it needs, not broad HCM read/write access.

Architecture: app, agent, workflow

Split the build into three pieces with distinct jobs.

The workflow is deterministic and runs the same way on every hire: receive the Greenhouse event (webhook or scheduled poll of GET /v3/offers), pull the related candidate and application records, run field validation, check for a duplicate candidate ID already in flight, and route the record to either "ready for HR approval" or "needs review." None of this uses an AI model. It is code, so it is auditable and cheap to run at volume.

The agent only handles judgment calls: translating Greenhouse's free-text department or job title into the closest Workday Supervisory Organization or Cost Center reference, writing a plain-language explanation when a required field is missing, and flagging likely rehires by matching name and prior employment dates. The agent never decides whether to submit the hire to Workday. It drafts an explanation; a person approves.

The app is the human interface and the system of record for this process. It holds the managed tables that track every hire's state across both systems, long after the Slack message or chat session that started it has disappeared. This is what makes the work stateful: the record of "this hire was approved by Maria on November 5 with a corrected start date" lives in a database row, not in someone's memory of a conversation.

Architecture diagram showing the Greenhouse-to-Workday hire handoff: candidate-hired trigger, Greenhouse Harvest API, Major app and mapping agent, HR approval decision, and the Workday Hire Link or tenant process

Architecture: app, agent, and workflow around the Greenhouse-to-Workday hire handoff

Build it on Major, step by step

  1. Connect the connectors. In Major, add a custom API connector for Greenhouse Harvest using the base URL https://harvest.greenhouse.io/v3 with the bearer API key (or OAuth client credentials) your Greenhouse admin issues under the HRIS Link partner option, and a webhook endpoint secret for the candidate_hired event. Add a second custom API connector for Workday pointed at your tenant's REST base URL, authenticated with the Integration System User's OAuth client credentials. IT owns both connectors in Major's central credential store; no API key or secret ever appears in a prompt or in app code. You should see both connectors listed as active resources with scoped permissions, not full-account access.
  2. Build the app. Create a Hire Readiness app with three managed tables: hire_records (Greenhouse candidate ID, application ID, offer ID, mapped Workday fields, status), field_exceptions (which field was missing or ambiguous, the agent's explanation, resolution), and approvals (who approved, when, what changed). Add a screen listing hires by status: received, needsreview, approvedforhandoff, confirmedin_workday. You should see a table where every row is a real candidate pulled from Greenhouse, not a mockup.

Example prompt to build this app: "Build an app with a hires table tracking Greenhouse candidate ID, name, job, department, compensation band, start date, Workday supervisory organization, and a status field with values received, needsreview, approvedforhandoff, confirmedin_workday. Add a detail view per hire showing any field exceptions and an approve button."

  1. Add the agent that uses the app. Give it read access to the hire_records and field_exceptions tables and instructions limited to mapping and explanation, never approval or submission.

Example prompt to build the agent: "When a hire record has a blank supervisory organization or an ambiguous department name, look up the closest match from the department-to-supervisory-org reference table, write a one-sentence explanation of the match or the gap, and update the fieldexceptions table. Never mark a record approvedfor_handoff yourself."

  1. Set the workflow trigger. Configure the workflow to fire on the Greenhouse candidate_hired webhook (with HMAC signature verification against the stored secret), falling back to an hourly poll of GET /v3/offers?status=Accepted as a safety net if a webhook delivery is missed. On each trigger, the workflow pulls the candidate and application records, runs field validation in code, and writes a new row to hire_records. You should see a new row appear within minutes of marking a test candidate hired in a Greenhouse sandbox.
  2. Test it. Run a test hire through a Greenhouse sandbox or a staging job, confirm the webhook signature validates, confirm a deliberately incomplete record (blank start date) lands in needs_review with an agent explanation, and confirm a complete record reaches approved status after a human click. You should see both the happy path and the exception path produce a correct, auditable row.
  3. Roll out with permissions. Scope the app so HR onboarding can view and approve hire records, HRIS admin can edit field mappings and the Workday connector configuration, and IT/security can view audit logs but not compensation fields unless they are also HR. Turn on Slack alerts to the HR onboarding channel for anything sitting in needs_review more than one business day. You should see role-appropriate views when you log in as each persona.

Once approved, the workflow either calls your Workday tenant's configured hire-initiation process, wherever your HRIS admin has validated that write schema, or confirms Greenhouse's own Hire Link has already completed the export, then polls GET /workers/{id} to reconcile the worker record before marking the row confirmedinworkday.

Governance and IT control

Every connector credential lives in Major's central credential store, scoped per connector and governed by IT, never embedded in app code or agent prompts. The Greenhouse Harvest key only needs read access to Offers, Candidates, and Applications. The Workday credential should be scoped to Staffing and the specific business process object your tenant uses, not blanket HCM access.

Role-based access on the Hire Readiness app controls who sees what: HR onboarding sees status and can approve, HRIS admin can edit mappings, and anyone without an HR role is excluded from compensation fields entirely. This is enforced at the app layer, not by convention.

Every write to Workday, and every approval in the app, is logged with who acted, when, and what the record looked like before and after. SSO governs who can log into the app at all, so access follows your existing identity provider rather than a separate login. Major's managed database and storage mean this audit trail persists independently of any single chat session or agent run, which is what makes it something IT can actually review during an audit rather than something that lives in a transcript nobody saved.

Deploys of the app, agent, and workflow are versioned, so a change to the field-mapping logic is traceable to a specific release rather than a silent prompt edit. Any step that writes to Workday requires the human approval step described above; the workflow itself never has unsupervised write access.

Failure handling and edge cases

Real hiring data is messier than the happy path, so the workflow needs explicit handling for at least these cases:

  • Greenhouse webhook delivery fails. The hourly poll of GET /v3/offers?status=Accepted catches hires the webhook missed, using resolved_at as the dedupe key.
  • Duplicate candidate_hired events. Greenhouse's Greenhouse-Event-ID header lets the workflow discard a delivery it already processed.
  • Rehire looks like a new hire. The agent flags a name-and-prior-employment match for human review instead of letting a new worker record get created on top of an existing one.
  • Canceled offer after the hire record was created. If the offer status changes away from Accepted, the workflow marks the record canceled and alerts HR instead of leaving a stale row.
  • Changed start date. A start-date update after approval reopens the record for re-approval rather than silently overwriting an already-approved submission.
  • Staffing-model mismatch. In Hybrid mode with an ambiguous Supervisory Organization, the record holds in needs_review rather than guessing position-based or job-based.
  • Workday API error or rate limit. The workflow retries with exponential backoff and surfaces a persistent failure to the exception queue.
  • Partial Workday confirmation. If GET /workers/{id} shows a worker missing an expected field, the record stays open rather than being marked fully resolved.

The agent must never submit a record to Workday on its own, never override a human's prior approval, and never guess a compensation figure that was not in the Greenhouse offer. When uncertain, it writes an explanation and waits. That fallback to a person is the entire point of the approval gate.

Approval path diagram showing deterministic validation, the agent's explanation step for missing or ambiguous fields, HR's exception queue, and approval before the Workday hire process runs

Approval path: what runs straight through versus what HR reviews

A worked example with numbers

For example, say a mid-size company hires about 15 people a month through Greenhouse into Workday. HR onboarding currently spends roughly 20 minutes per hire manually re-keying offer data and double-checking it against the offer letter, a little over 5 hours a month of repetitive, error-prone work.

Take one illustrative record: Maya Chen accepts an offer for a Senior Analyst role on November 2, 2026. The recruiter marks her hired in Greenhouse on November 5, with a start date of November 16.

The candidate_hired webhook fires the moment she is marked hired. The workflow pulls her candidate, application, and offer records within seconds, including compensation band, department ("Data & Analytics"), and start date. Validation finds the Supervisory Organization field blank, because "Data & Analytics" has no exact match in the department-to-org reference table.

The record lands in needs_review. The agent finds the closest Supervisory Organization match, "Analytics & Insights," and writes a one-sentence note explaining the match and that it was used in two prior hires this quarter. It does not submit anything.

An HR onboarding specialist sees the Slack alert, confirms the match, and clicks approve. The record moves to approvedforhandoff, and the organization's configured Hire Link integration runs the actual Workday hire. The workflow polls GET /workers/{id} the next morning, confirms the worker record matches, and marks the row confirmedinworkday.

Total human time on this hire: about 2 minutes to review and approve, versus the roughly 20 minutes it replaced. Across 15 hires a month, that is the difference between roughly 5 hours and about 30 minutes of HR time on this step, with a complete record of who approved what and when. These are illustrative, round numbers for a fictional scenario, not a measured customer result.

What to measure

Once this is running, track a handful of metrics HR onboarding already cares about. None of these require a new reporting tool, since the app's managed tables already hold every status change and timestamp needed to compute them.

  • Time from marked-hired to confirmed-in-Workday, to see whether the handoff is keeping pace with start dates. A widening gap here is usually the first sign the mapping table has drifted out of date.
  • Percentage of hires that land in needs_review, which tells you how often the department-to-org mapping table needs updating. A rising rate usually means a reorg or a new department naming convention upstream in Greenhouse.
  • Number of duplicate or rehire flags caught before submission, as a proxy for errors avoided that would otherwise have shown up as duplicate worker records in Workday.
  • Average HR review time per exception, to see whether the agent's explanations are actually speeding up resolution rather than just relocating the same manual work into a different screen.
  • Reconciliation mismatches found after confirmation, meaning cases where Workday's worker record did not match what was approved, which should trend toward zero as the mapping table matures.

Review these monthly with the HRIS admin who owns the staffing-model configuration, since most drift in these numbers traces back to a Greenhouse or Workday configuration change rather than a bug in the workflow itself.

Frequently asked questions

Does Greenhouse send a candidate to Workday as soon as an offer is accepted?

No. Greenhouse's Hire Link documentation states the export to Workday runs when the candidate is marked as hired, a separate and later step than the offer being accepted. Build your trigger around the hire event, not the offer-accepted status alone.

What does Greenhouse Hire Link for Workday support?

Hire Link supports New Hire, Rehire, and Transfer hire types, with field requirements that depend on whether your organization uses Position Management, Job Management, or Hybrid staffing models in Workday. It does not support contingent-worker business processes.

Can the Workday Workers API create a new worker?

No. The public Workers reference documents retrieval operations (GET /workers and GET /workers/{id}), not a create endpoint. Hire initiation runs through Greenhouse's Hire Link integration or a tenant-specific Workday business process your implementation partner configures, not a generic public write endpoint.

What should happen when required hire data is missing?

The record should hold in a needs_review state rather than being submitted partially. The agent should name the specific missing field and its source, and route the record to the HR onboarding or HRIS admin owner, never guess or submit incomplete data to Workday.

How can HR prevent duplicate Workday hires?

Use Greenhouse's stable candidate and application IDs as the dedupe key, check the Greenhouse-Event-ID header to avoid reprocessing the same webhook delivery twice, and flag likely rehires for manual review before they are submitted as new hires. Reconcile against Workday's Workers endpoint after submission to confirm there is exactly one matching record.

Does this replace Greenhouse's Hire Link or Workday's configuration?

No. This build does not replace either system's native integration or configuration. It adds a validation, approval, and audit layer around whichever Workday hire path your organization already has enabled, so a person reviews every handoff before it runs.

Before you go live

Before you point this at real candidates, walk through this checklist with HR onboarding, HRIS admin, and IT together. Most of the risk in this build is configuration drift between Greenhouse and Workday, not the Major app itself, so confirming each of these up front avoids a bad first week.

  • [ ] Greenhouse Harvest API credential scoped to Offers, Candidates, and Applications only, stored in Major's credential proxy
  • [ ] Workday Integration System User credential scoped to Staffing and the specific business process object, not broad HCM access
  • [ ] candidate_hired webhook registered with HMAC signature verification and a fallback hourly poll configured
  • [ ] Test hire run through a sandbox covering both a complete record and a deliberately incomplete one
  • [ ] Role-based access confirmed: HR onboarding can approve, HRIS admin can edit mappings, compensation fields restricted
  • [ ] Slack alert configured for records sitting in needs_review past one business day
  • [ ] Duplicate and rehire detection logic tested against a known rehire scenario
  • [ ] Reconciliation step against GET /workers/{id} confirmed to catch partial or mismatched confirmations
  • [ ] Staffing model (Position Management, Job Management, or Hybrid) confirmed with the Workday admin so required-field logic matches your tenant

More hr AI automation use cases

Start building on Major

Build a Greenhouse-to-Workday handoff app that validates each hire, preserves its state, and routes exceptions to HR before the supported Workday process runs.

Related articles

About the author

Ritvij Gautam is Head of Growth at Major.

Last reviewed November 17, 2026 by Ritvij Gautam.

Frequently asked questions

Does Greenhouse send a candidate to Workday as soon as an offer is accepted?
No. Greenhouse's Hire Link documentation states the export to Workday runs when the candidate is marked as hired, a separate and later step than the offer being accepted. Build your trigger around the hire event, not the offer-accepted status alone.
What does Greenhouse Hire Link for Workday support?
Hire Link supports New Hire, Rehire, and Transfer hire types, with field requirements that depend on whether your organization uses Position Management, Job Management, or Hybrid staffing models in Workday. It does not support contingent-worker business processes.
Can the Workday Workers API create a new worker?
No. The public Workers reference documents retrieval operations (GET /workers and GET /workers/{id}), not a create endpoint. Hire initiation runs through Greenhouse's Hire Link integration or a tenant-specific Workday business process your implementation partner configures, not a generic public write endpoint.
What should happen when required hire data is missing?
The record should hold in a needs_review state rather than being submitted partially. The agent should name the specific missing field and its source, and route the record to the HR onboarding or HRIS admin owner, never guess or submit incomplete data to Workday.
How can HR prevent duplicate Workday hires?
Use Greenhouse's stable candidate and application IDs as the dedupe key, check the Greenhouse-Event-ID header to avoid reprocessing the same webhook delivery twice, and flag likely rehires for manual review before they are submitted as new hires. Reconcile against Workday's Workers endpoint after submission to confirm there is exactly one matching record.
Does this replace Greenhouse's Hire Link or Workday's configuration?
No. This build does not replace either system's native integration or configuration. It adds a validation, approval, and audit layer around whichever Workday hire path your organization already has enabled, so a person reviews every handoff before it runs.