If you’ve ever waited on a prior authorization, chased a chart across fax and phone, or watched clinicians spend more time clicking than caring, you know something has to change. The HL7 Da Vinci Project aims to make that change practical: it’s a collaborative effort that turns FHIR into a set of ready-to-use patterns for payers, providers, and technology teams so data can flow where it’s needed — faster, more reliably, and with less manual work.
In plain terms, Da Vinci isn’t another standards document hidden in jargon. It’s a playbook of real-world FHIR guides — profiles, APIs, and exchange patterns — designed to solve everyday friction points like prior authorization, clinical data requests, payer-to-payer transfers, provider directories, and quality reporting. The goal is simple: let machines do what machines do best (move and validate data), so people can do what people do best (care for patients and make timely decisions).
This article walks you through the parts of Da Vinci that matter and how to use them. You’ll get:
- Clear explanations of the most useful Da Vinci guides and when to use each one.
- A practical implementation roadmap: pick a high-friction use case, map it to Da Vinci patterns, stand up the FHIR layer, and test with real tools.
- What regulators and timelines mean for payers and providers, and how Da Vinci lines up with those expectations.
- Concrete ways AI can amplify Da Vinci — for example, speeding document retrieval, auto-filling authorization requirements, and reducing manual review.
No theory — just actionable advice and checkpoints you can use today, whether you’re on the payer side, in a clinic, or building software for the health system. Read on and you’ll come away with a clear sense of which Da Vinci guides to prioritize and how to get from pilot to production without getting lost in the technical weeds.
What the HL7 Da Vinci Project solves (in plain terms)
A community effort to make payer–provider data exchange work at scale
Health plans, provider organizations, vendors, and toolmakers all need the same thing: reliable, predictable access to the same patient and administrative data when they need it. Today that exchange is often brittle — custom integrations, different data formats, faxes, and manual phone-and-email workarounds create delays, errors, and extra cost. Da Vinci is a practical, community-driven attempt to fix that by agreeing on common, re-usable patterns and API behaviors so systems can talk the same language. Instead of every payer and provider reinventing the same point-to-point plumbing, Da Vinci gives teams shared building blocks they can adopt and extend, which makes large-scale exchange practical rather than piecemeal.
Focus areas: value-based care, burden reduction, and real-time decisions
Da Vinci targets the places where better data flow has the biggest operational and clinical impact. That includes support for value-based arrangements (so outcomes and risk information move cleanly between payer and provider), cutting administrative friction (coverage checks, document exchange, prior authorization workflows), and enabling faster, more informed decisions at the point of care. The net effect is less chasing and rekeying for staff, fewer surprises for patients, and more timely clinical and utilization decisions because the right evidence can move where it’s needed, when it’s needed.
Where Da Vinci fits with FHIR R4, US healthcare workflows, and TEFCA networks
Da Vinci is built on FHIR implementation patterns: it defines how to use FHIR resources, profiles, and APIs to represent the real-world payer–provider exchanges that organizations need. That means it doesn’t replace FHIR — it narrows and prescribes how FHIR should be used for specific payer/provider scenarios so implementers have less ambiguity. In the U.S. context, Da Vinci maps to familiar operational workflows (authorization, data requests, quality reporting, provider directories) and is designed to work over modern API-based exchange layers and national connectivity frameworks, so it can scale beyond isolated integrations to broader networks.
Understanding these problems at a high level makes the next step obvious: which specific FHIR-based guides and patterns to pick first and how they line up with the workflows your team is trying to fix. We’ll walk through those practical guides next so you can map them to your highest-friction use cases and start delivering value quickly.
Da Vinci FHIR guides you’ll actually use
HRex: the shared foundation for Da Vinci profiles and patterns
HRex (Health Record Exchange) provides the common building blocks — standard resource shapes, search patterns, and API behaviors — that the rest of the Da Vinci guides rely on. Think of HRex as the baseline constraints and conventions that make different implementations predictable: consistent resource profiles, agreed identifiers, and common error/operation semantics so tools and systems can interoperate without brittle custom mappings.
CDex: request and send clinical data between payers and providers
CDex (Clinical Data Exchange) defines how a payer or provider requests specific clinical evidence and how a responding system packages and returns the exact chart snippets needed. It reduces chasing and faxing by specifying query parameters, document structure, and common expectations about what counts as responsive clinical data for authorizations, appeals, or case reviews.
PDex: member health history and payer-to-payer exchange
PDex standardizes member-centric health histories and supports payer-to-payer handoffs (for example, when a member changes plans). It focuses on reliably conveying what is known about a patient’s conditions, medications, and encounters so downstream systems don’t lose context during transitions or reconciliation events.
Plan-Net: provider directory for health plans
Plan-Net gives plans a machine-readable way to publish and query provider networks, affiliations, and endpoint metadata. That enables provider lookups, directory validation, and routing decisions for referrals and prior authorizations without manual directory maintenance or inconsistent formats.
DEQM + Gaps in Care: quality measure data and closure tracking
DEQM (Data Exchange for Quality Measures) plus Gaps-in-Care patterns let organizations exchange quality-measure evidence and track whether identified care gaps have been closed. This supports value-based reporting, automates parts of quality workflows, and helps plans and providers act on timely signals rather than stale claims-only measures.
Member Attribution (ATR): align members to providers and contracts
ATR helps formalize how members are attributed to clinicians, care teams, or contracts. Clear attribution matters for risk, quality reporting, and value-based payment reconciliation — ATR defines the data and messaging to keep everyone aligned on who’s responsible for a patient’s outcomes.
Patient Cost Transparency (PCT): upfront cost estimates for patients
PCT defines how plans and providers exchange eligibility, benefits, and allowed-amount information to produce reliable out-of-pocket estimates for patients. By standardizing the inputs and responses, PCT makes cost-check calls faster and more automatable at scheduling or point-of-care.
Burden Reduction—CRD, DTR, PAS: coverage checks, required docs, and prior auth
Da Vinci’s burden-reduction guides tackle the high-friction administrative tasks that consume clinicians’ and staff time. “Administrative burdens are large and measurable: administrative costs represent ~30% of total healthcare costs, clinicians spend ~45% of their time in EHRs, and 50% of healthcare professionals report burnout — all drivers for automation and data-exchange efforts like Da Vinci’s burden-reduction guides.” Healthcare Industry Challenges & AI-Powered Solutions — D-LAB research
Concretely, CRD (Coverage Requirements Discovery) helps systems discover what documentation or criteria a payer needs, DTR (Documentation Templates and Rules) standardizes the structure for what to collect, and PAS (Prior Authorization Support) defines the request, status, and response flows so authorizations can be automated or at least tracked programmatically.
Risk Adjustment (RA): share evidence to support accurate risk scoring
RA patterns support sharing clinical evidence that underpins risk scores used by payers. By standardizing how supporting documentation is requested and returned, RA exchanges reduce the burden of manual chart review and improve the completeness and auditability of risk-adjustment submissions.
Now that you know which guides map to which operational problems, the practical next step is to match these guides to your highest-friction workflows and plan a phased rollout that delivers measurable wins quickly.
Implementation roadmap: map workflows to guides, then ship
Pick high-friction use cases first: prior auth, quality reporting, or payer data exchange
Start small and strategic. Choose one or two workflows where automation will free the most staff time or reduce the most avoidable cost — common choices are prior authorization, quality reporting, or payer-to-payer transfers. Define the success criteria up front (e.g., shorter turnaround, fewer document requests, measurable staff-time savings) so every decision is tied to a business outcome.
Run a gap analysis: data availability, coding/terminology, and consent flows
Map the chosen workflow end-to-end and compare your current state to the Da Vinci guide(s) you plan to adopt. Key questions: where does the needed data live, what code systems (CPT, ICD, SNOMED, LOINC) are used today, which elements are missing or in free text, and what consent or identity checks are required? Capture integration, privacy, and operational gaps so you can prioritize fixes that unblock the biggest risks.
Stand up the FHIR layer: APIs, subscriptions, and vocabulary services
Implement the minimal FHIR façade that supports your use case: well-documented REST endpoints, OAuth2-based security, and subscription/webhook hooks if you need push notifications. Pair that with a vocabulary service (code/value set resolution and mapping) and a translation/mapping layer to normalize internal data to the Da Vinci profiles. Keep the initial scope narrow — a small, stable API is easier to test and iterate on than a broad, unfinished one.
Test early and often: HL7 Connectathons, reference sandboxes, and validation tooling
Validate your implementation before production by exercising real exchange scenarios. Use community testing opportunities and reference sandboxes to simulate partner interactions, run automated validation against Da Vinci profiles, and invite pilot partners to end-to-end tests. Early testing exposes mismatches in expectations, coding, and error handling when they’re cheap to fix.
Track outcomes: turnaround time, denial rates, staff hours, and audit readiness
Instrument the workflow to measure the outcomes you defined at the start. Track metrics such as request-to-decision time, number of follow-up document requests, avoidable denial rates, and staff hours spent per case. Use these measures to prove value, prioritize the next wave of work, and document audit-ready evidence for compliance or payer reconciliation.
Tie each technical milestone to an operational change (training, updated SOPs, partner onboarding) and iterate in short cycles: deliver a small win, measure it, then expand scope. With this disciplined approach you’ll move from pilot to scale while keeping risk and cost under control — and you’ll be ready to adapt as external timelines and compliance expectations evolve.
Thank you for reading Diligize’s blog!
Are you looking for strategic advise?
Subscribe to our newsletter!
Regulatory gravity: CMS interoperability and prior authorization timelines (2026–2027)
Why Da Vinci aligns with Provider Access, Payer-to-Payer, and Prior Auth APIs
Regulators are pushing the industry toward API-first exchange: standardized, auditable, machine-readable APIs that let systems exchange eligibility, claims, clinical evidence, and authorization status. Da Vinci’s FHIR-based guides were created specifically to model those real-world exchanges — the same flows regulators expect to be automated — so adopting Da Vinci reduces rework and speeds compliance. In short, implementing Da Vinci maps directly to the technical patterns and message semantics that regulatory guidance favors, which lowers integration risk when oversight and reporting requirements tighten.
Transparency and speed: status updates, decision timeframes, and attachments
Regulatory pressure is as much about process as data: auditors and regulators want clear, timely status updates, measurable decision timeframes, and a reliable way to exchange supporting documents. Da Vinci patterns for prior authorization and status tracking provide the APIs and payload conventions needed to publish request status, capture required attachments, and surface decision reasons. That means operational teams can move from opaque, phone-and-fax workflows to tracked, automatable exchanges where every step is logged, timestamped, and easier to audit.
Practical prep by role: what plans, providers, and vendors should prioritize
Payers: prioritize the APIs and backend mapping that make eligibility, benefits, and prior authorization status queryable. Invest in a vocabulary/value-set service and an attachments pipeline so requests can be evaluated programmatically and evidence stored auditablely. Define KPIs you’ll need to report (turnaround, re-requests, denials) and instrument them now.
Providers: focus on internal workflows that will feed APIs — where clinical notes, imaging, and structured problem lists live — and how to export them reliably. Start with the smallest path to automation for your busiest authorizations: a predictable template for required documentation and a way to attach chart snippets so external requests are satisfied without manual chase.
Vendors and integrators: build or harden FHIR façades, OAuth2 security flows, and subscription/webhook support so partners can get push notifications rather than polling. Offer mapping tools that convert local data models into Da Vinci profiles and pre-built connectors for common EHRs and payer systems to shorten pilot cycles.
Across roles, treat the work as both technical and operational: pair API builds with updated SOPs, partner onboarding documents, and training so endpoint availability translates into actual downstream impact.
With the regulatory tailwind making API-based exchange the de facto expectation, organizations that combine pragmatic Da Vinci implementations with operational changes will move from compliance projects to operational improvements — and that sets the stage for where AI can amplify those gains by automating documentation, retrieval, and triage.
Where AI amplifies Da Vinci—practical wins and ROI
DTR + ambient scribing: auto-fill requirements, cut after-hours EHR time by ~30%
Da Vinci’s DTR patterns define what documentation payers need; AI ambient scribing can produce that documentation with far less clinician effort. “AI-powered clinical documentation has demonstrated measurable reductions in clinician burden — studies and pilots report ~20% reductions in clinician EHR time and ~30% decreases in after-hours (“pyjama time”), supporting DTR + ambient scribing as a high-impact complement to Da Vinci.” Healthcare Industry Challenges & AI-Powered Solutions — D-LAB research
In practice, ambient scribing plus DTR means templates and required fields are pre-populated, clinicians only validate or correct, and the submitted evidence already conforms to the structure payers expect—faster reviews, fewer re-requests, and meaningful clinician time reclaimed.
CDex + AI retrieval: extract the right chart snippets, reduce chase calls and faxing
Combine CDex’s standardized queries with AI-powered document retrieval and summarization so systems can locate the exact clinical snippets that satisfy a data request. Rather than pulling full charts or relying on manual searches, an AI layer can find relevant notes, labs, and imaging reports, summarize them, and package them in the CDex-prescribed format for automated exchange. The operational win: fewer phone calls, less faxing, and shorter response cycles for clinical evidence requests.
PAS triage with NLP: route requests, pre-check criteria, lower avoidable denials
Natural language models can triage incoming prior authorization requests against payer criteria (CRD/DTR) and surface missing items before human review. That means many requests can be auto-routed or auto-completed with minimal human touch—only the complex cases reach specialty reviewers. The result is lower avoidable denials, fewer return-for-information events, and a higher throughput of straightforward approvals.
DEQM-driven quality: auto-calc gaps, lift closure rates with timely data
AI can continuously scan exchanged clinical data (via DEQM and Gaps patterns) to compute measure logic, surface patients with care gaps, and recommend targeted outreach. When combined with Da Vinci’s quality-data exchanges, organizations move from retrospective claims-based reporting to proactive, near-real-time gap closure — improving measure performance and reducing manual chart pulls for audits.
Admin ops boost: AI scheduling and billing to reduce no-shows and coding errors
Operational AI (scheduling optimization, intelligent reminders, billing validation) complements Da Vinci’s administrative APIs by reducing friction upstream of clinical exchange. Smarter scheduling lowers no-shows and the cascade of rescheduling work; automated coding checks reduce billing edits and rework so payer–provider exchanges happen against cleaner, more reliable data.
How to prioritize: start with the smallest high-volume win (e.g., ambient scribe for the top 10 authorization types or an AI CDex retriever for the busiest service lines), instrument the change (track time saved, re-requests, and denial delta), and then scale. When Da Vinci’s standard exchanges are paired with focused AI automation, organizations turn compliance and connectivity projects into measurable operational ROI and better clinician and patient experiences.