HR Open Schema: Portable Candidate Data Without Pipeline Drift

A pragmatic playbook for RevOps to reduce integration churn, speed rollouts, and keep fraud controls intact by standardizing candidate data on HR Open.

IntegrityLens promo
Schema drift is not a data problem. It is a revenue problem that shows up as funnel leakage, audit gaps, and weakened fraud controls.
Back to all posts

When a schema change turns into a revenue incident

A VP Sales promises a start date to a strategic customer. Two days before the offer, your background check vendor rejects the candidate because the identity verification packet is missing the document type and country fields. Those fields existed last quarter, but your new scheduling tool overwrote the candidate record with a slimmer payload. Nobody saw the drift because the integration still returned 200 OK. This is the failure mode RevOps gets blamed for: speed goes down, cost goes up, and you cannot explain the discrepancy cleanly to Finance, Legal, or the board. By the end, you will know how to implement an HR Open based canonical schema, version it, map every tool to it, and roll it out with canaries and rollback so candidate data stays portable and auditable.

Why HR Open style schemas make hiring data portable

Recommendation: define one canonical schema (HR Open aligned) and treat every vendor payload as an adapter to that schema, not the other way around. This prevents tool swaps from redefining your business data. HR Open provides a shared vocabulary for core HR and recruiting entities (candidate, job, application, stage). You do not need perfect coverage of every vendor field. You need a stable contract for the fields that run your business: identity gating status, interview events, assessment results, offer states, and audit references. For RevOps, portability means you can change tools without breaking: (1) stage conversion rates, (2) time-in-stage metrics, (3) risk controls like Risk-Tiered Verification, and (4) evidence trails that protect your reputation when something goes wrong.

  • Canonical IDs: candidate_id, application_id, job_id

  • Stage model: sourced, verified, interviewed, assessed, offer, hired (map vendor stages into these)

  • Risk signals: verification_status, risk_tier, decision_reason_code

  • Evidence pointers: evidence_pack_id(s), artifact URIs, immutable timestamps

  • Attribution: source_channel, campaign, recruiter_id

Ownership, automation, and sources of truth

Recommendation: write down a single ownership matrix before you write code. Schema governance fails when everyone assumes someone else is watching drift. Owner model that works in practice: Recruiting Ops is the business owner of stage semantics and required fields. Security owns identity and biometric constraints (what is collected, retained, and who can access). RevOps owns metric definitions, dashboards, and the change control gate for anything that affects reporting. Automated vs reviewed: schema validation is automated on every inbound event; high-risk verification outcomes go to a manual review queue; mapping exceptions create tickets with an SLA so they do not rot. Sources of truth: ATS is the system of record for application and stage progression; verification service is the system of record for identity outcomes; interview and assessment systems are systems of record for their raw evidence, but must publish normalized results back to the canonical schema.

  • Recruiting Ops (A): canonical schema fields, stage mapping, recruiter workflow

  • Security (A): Risk-Tiered Verification policy, Zero-Retention Biometrics settings, access controls

  • RevOps (A): funnel definitions, attribution fields, change approvals

  • Engineering (R): adapters, idempotent webhooks, observability, replay tooling

  • Hiring Managers (C): exception approvals for high-risk escalations

canonical schema, adapters, and safe rollouts

1

Define the canonical schema contract. Use HR Open entity names where possible (Candidate, Job, Application) and add a narrow set of extensions for integrity signals (verification, fraud, assessment). Mark required fields, allowed enums, and PII classifications.

2

Build adapter mappings for each tool. Every inbound payload is transformed into the canonical schema and validated. If validation fails, you do not drop the event silently. You quarantine it to a dead-letter queue and alert the owner.

3

Implement idempotent delivery. Every event includes an idempotency key so retries do not create duplicate stage changes or duplicate assessments. Prefer OAuth/OIDC over static API keys for outbound calls, and scope tokens per integration.

4

Add resilient connectivity. When the ATS is down, queue normalized events and replay them when it recovers. Your hiring pipeline cannot block verification or interviews because an ATS endpoint is flaky.

5

Roll out with canaries and a kill switch. Start with one requisition or one region, compare stage metrics and verification completion rates to baseline, and be able to revert the mapping version quickly if drift is detected.

6

Attach Evidence Packs. For any integrity-relevant decision (verification fail, suspected proxy interview, assessment anomaly), store the evidence references and decision codes in the canonical record so audits are defensible without hunting across tools.

  • Schema versioning: semver your contract and require explicit upgrade notes

  • Contract tests: replay recorded vendor payloads in CI against the validator

  • Metric parity checks: compare conversion counts pre and post mapping change

  • Alerting: notify when required fields arrive null or enums go out of range

  • Access controls: least privilege on who can view PII and evidence links

A working HR Open style schema contract (example)

Use this as a starter contract. It is intentionally opinionated for hiring integrity: it makes verification and evidence first-class fields so they cannot disappear into notes.

IntegrityLens key visual

Anti-patterns that make fraud worse

Avoid these because they increase funnel leakage and reduce defensibility under audit.

  • Let every vendor write directly into the ATS candidate object with their own field names and optionality.

  • Store identity verification outcomes as free-text notes or PDFs without structured fields and decision codes.

  • Treat mapping breaks as "integration noise" and fix them ad hoc without versioning, parity checks, and replay.

Where IntegrityLens fits

IntegrityLens AI is the first hiring pipeline that combines a full Applicant Tracking System with advanced biometric identity verification, AI screening, and technical assessments, so your canonical schema has one primary home instead of four disconnected tools. In practice, teams use IntegrityLens to keep HR Open style portability while also enforcing Risk-Tiered Verification and producing audit-ready Evidence Packs. IntegrityLens supports the full pipeline: Source candidates - Verify identity - Run interviews - Assess - Offer. It is used by TA leaders and recruiting ops to run workflow, by CISOs to approve identity and data controls, and by operators who need clean webhooks and observability for integrations.

  • ATS workflow with stage governance and audit trails

  • Biometric verification (document + voice + face) in 2-3 minutes, typically under 3 minutes before interviews

  • AI screening interviews available 24/7 across time zones

  • Technical assessments across 40+ programming languages

  • Security posture: 256-bit AES encryption, GDPR/CCPA-ready controls, runs on Google Cloud SOC 2 Type II audited and ISO 27001-certified infrastructure

What the fraud stats imply for RevOps (and what they do not)

The Checkr manager survey (31% reporting a false identity interview) implies identity fraud is not rare enough to ignore, so schema fields that carry verification results should be required, not best-effort. It does not prove your loss rate or the effectiveness of any specific control, because it is self-reported and depends on detection and awareness. The Pindrop pipeline observation (1 in 6 remote applicants showing signs of fraud) implies remote hiring pipelines should assume adversarial behavior and instrument for it, including structured fields for risk tier and evidence references. It does not prove causality for any single vendor or method, and "signs of fraud" is detection-dependent. For RevOps, the operator takeaway is simple: if you cannot trace identity and assessment outcomes through one schema and one candidate_id, your funnel metrics are not decision-grade.

Sources

External stats referenced in this article:

Related Resources

Key takeaways

  • A canonical HR Open schema reduces funnel metric drift when tools change, because every event maps to one contract.
  • Schema versioning and explicit mappings are a revenue protection move: they prevent silent data loss that breaks attribution and compliance.
  • Identity and fraud signals must be first-class fields in the schema, not vendor-specific notes, or you lose defensibility.
  • Resilient connectivity needs an outage mode: queue events when ATS is down and replay idempotently.
  • Observability is non-negotiable: trace one candidate_id across ATS, verification, interview, and assessment.
HR Open style Candidate and Application contract (v1.2.0)YAML contract

A canonical schema contract you can enforce at every integration boundary.

Includes integrity signals (verification, risk tier, evidence) as required structured fields.

Designed for idempotent webhook delivery and replay when the ATS is unavailable.

version: 1.2.0
standard: hr-open-inspired
entities:
  Candidate:
    required:
      - candidate_id
      - legal_name
      - primary_email
      - created_at
      - pii_classification
    fields:
      candidate_id:
        type: string
        description: "Canonical candidate identifier used across all tools."
      legal_name:
        type: object
        required: [given, family]
      primary_email:
        type: string
        format: email
      created_at:
        type: string
        format: date-time
      pii_classification:
        type: string
        enum: [restricted, confidential]
      identity_profile:
        type: object
        description: "Identity verification summary (structured, not free-text)."
        required: [verification_status, risk_tier, verified_at]
        fields:
          verification_status:
            type: string
            enum: [not_started, passed, failed, needs_review]
          risk_tier:
            type: string
            enum: [low, medium, high]
          verified_at:
            type: string
            format: date-time
          evidence_pack_id:
            type: string
            description: "Pointer to an Evidence Pack that explains the outcome."
          zero_retention_biometrics:
            type: boolean
            description: "True if biometric artifacts are not retained beyond processing."
  Application:
    required:
      - application_id
      - candidate_id
      - job_id
      - stage
      - stage_updated_at
    fields:
      application_id:
        type: string
      candidate_id:
        type: string
      job_id:
        type: string
      source_channel:
        type: string
        description: "UTM or channel name normalized by RevOps."
      stage:
        type: string
        enum: [sourced, verified, interviewed, assessed, offer, hired, rejected, withdrawn]
      stage_updated_at:
        type: string
        format: date-time
      interview:
        type: object
        fields:
          interview_type:
            type: string
            enum: [live, async_ai]
          interview_event_id:
            type: string
          started_at:
            type: string
            format: date-time
          completed_at:
            type: string
            format: date-time
      assessment:
        type: object
        fields:
          provider:
            type: string
          assessment_id:
            type: string
          language:
            type: string
          score:
            type: number
          integrity_flags:
            type: array
            items:
              type: string
              enum: [none, suspicious, likely_proxy, ai_assist_detected]
      audit:
        type: object
        required: [idempotency_key]
        fields:
          idempotency_key:
            type: string
            description: "Prevents duplicate stage transitions on retry."
          mapping_version:
            type: string
            description: "Schema mapping version used by the adapter."
webhooks:
  delivery:
    retry_policy:
      max_attempts: 8
      backoff: exponential
    dead_letter_queue: required
    signature_verification: required
    auth:
      preferred: oauth_oidc
      discouraged: api_keys
rollout_controls:
  kill_switch: true
  canary:
    strategy: "by-job-id"
    initial_scope:
      max_jobs: 3
      max_days: 7
observability:
  trace_fields:
    - candidate_id
    - application_id
    - audit.idempotency_key
  required_logs:
    - event_received_at
    - validation_result
    - delivery_status
    - dlq_reason

Outcome proof: What changes

Before

Every new hiring tool introduced a new candidate payload shape. RevOps spent cycles reconciling funnel reports, while Recruiting Ops dealt with broken automations and Security lacked consistent evidence fields for identity exceptions.

After

A canonical HR Open style schema became the contract. Tool payloads were adapted and validated, integrity signals were required fields, and rollouts used canaries with a kill switch and replay for ATS outages.

Governance Notes: Legal and Security signed off because the contract explicitly classifies PII, enforces least-privilege access to evidence links, and supports Zero-Retention Biometrics for biometric artifacts. The workflow includes an appeal path for candidates when outcomes are "needs_review" and logs mapping_version plus idempotency_key for defensible change tracking. Data is protected in transit and at rest with 256-bit AES baseline encryption, and controls are designed to be GDPR/CCPA-ready with clear retention boundaries.

Implementation checklist

  • Pick one canonical candidate_id and one job_id that every system must use.
  • Define an HR Open based canonical schema with required fields and enumerations.
  • Version the schema and mapping rules, and publish them as a contract.
  • Instrument every integration with idempotency keys, retries, and a dead-letter queue.
  • Add a kill switch and canary rollout for any new vendor integration.
  • Require Evidence Packs for identity and assessment decisions, linked by candidate_id.

Questions we hear from teams

What is HR Open, and do we need full compliance to get value?
HR Open is a set of open standards and vocabularies for HR data. You do not need perfect or complete compliance. The value comes from adopting the entity model (Candidate, Job, Application) and enforcing a stable contract for the fields that drive workflow, integrity controls, and reporting.
Where does the canonical schema live: ATS, warehouse, or middleware?
For hiring operations, the canonical schema should be enforced at integration boundaries (middleware or platform) and reflected back into the ATS as the system of record for stage and disposition. Your warehouse should consume the same canonical events to prevent metric drift.
How do we handle ATS downtime without blocking hiring?
Queue normalized events and replay them with idempotency keys. Verification and interviews can proceed, but stage updates are delivered when the ATS recovers, preserving an ordered audit trail instead of forcing manual backfills.
What fields are most important for fraud prevention portability?
verification_status, risk_tier, verified_at, decision_reason_code, and evidence_pack_id are the core. Without structured versions of those fields, fraud and identity outcomes become vendor-specific and non-auditable.

Ready to secure your hiring pipeline?

Let IntegrityLens help you verify identity, stop proxy interviews, and standardize screening from first touch to final offer.

Try it free Book a demo

Watch IntegrityLens in action

See how IntegrityLens verifies identity, detects proxy interviewing, and standardizes screening with AI interviews and coding assessments.

Related resources