Prior Authorization Automation: Build Guide for CMS-0057-F
Prior authorization automation is software that checks whether a service needs approval, gathers the supporting documentation, submits the request electronically, tracks its status, and records the payer decision, sending only exceptions to staff. Built against the US federal rule, it also has to return a determination within 72 hours for expedited requests and seven calendar days for standard requests, and hold a timestamped record of every event along the way.
Ask a product lead how many payer integrations they expect to maintain in 2029 and the answer is usually a shrug. That shrug captures the scope of the work. The submission endpoint is the visible part, and it's also the part that changes most often.
The teams that do well treat this as a continuous interoperability operation. A payer rule registry, conformance tests against each capability statement, deadline clocks, and a clinician review queue that survives an audit. The build gets you to launch. The operation keeps approvals moving once payer policies, coding systems, and endpoints shift under you.
What Prior Authorization Automation Covers Across the Workflow
Five stages carry nearly every request, and each one fails in its own way. Map your product onto them before you pick a standard.
| Stage | What the system does | Data it needs |
|---|---|---|
| Requirements lookup | Confirms whether the service needs authorization and which documentation applies | Coverage rules, CPT or HCPCS codes, payer and plan identity |
| Documentation gathering | Pulls structured clinical data from the EHR and attaches supporting notes | Diagnoses, medications, prior treatments, imaging reports |
| Submission | Sends the request by payer API, X12 278, or portal fallback | Patient identity, ordering provider identifiers, service codes |
| Status tracking | Records acknowledgments, pending states, and requests for more clinical information | Timestamped events for each request |
| Decision and appeal | Captures approval or denial, denial reason, expiration date and appeal outcome | Structured denial reason, authorization dates, reviewer identity |
The manual cost concentrates in documentation gathering and in the reconciliation that follows a decision. Provider staff reported an average of 24 minutes per authorization working by phone, fax, or email and 16 minutes through a health plan portal, according to the 2024 CAQH Index. Most of those minutes go into retyping facts the EHR already holds and checking a portal screen against the original order.
Earlier research gives an order-of-magnitude sense of the money involved. The 2020 CAQH Index put a manually processed prior authorization at an average of $13.40 per transaction and estimated a $9.64 saving per transaction from moving to the HIPAA-mandated X12 278 electronic standard. Treat both as dated, US-only indicative figures that assume a particular staff cost and volume mix, then rebuild the case on your own payer mix.
Plain-language reference material helps when you are checking scope with clinicians. This collection of prior authorization resources covers payer terminology and the request categories that cause most rework.
A useful first exercise: label each of the five stages as owned by your product, integrated from another system, or still manual in your current release. The manual ones are your real backlog.
Why the CMS-0057-F Timeline Sets Your Build Priorities
What should shape your roadmap first: the decision clock or the API surface? Start with the clock. Under CMS-0057-F, impacted Medicare Advantage, Medicaid, CHIP, and federally facilitated Exchange payers must return prior authorization decisions for non-drug items and services within 72 hours for expedited requests and seven calendar days for standard requests, per the CMS-0057-F fact sheet. A dashboard that reports yesterday's queue totals stops being enough once a live case can breach a federal deadline this afternoon.

Instrumentation follows from that clock. Received, submitted, and decision timestamps become first-class fields, and every request needs an urgency flag captured at the moment it goes out, because the 72-hour and seven-day windows start at receipt, not at triage. The dates below set the build order. Treat each one as a regulatory target that CMS can and does move, and confirm it on cms.gov before it enters a plan.
| Requirement | Date | Detail |
|---|---|---|
| Decision timeframes for non-drug items and services | Compliance date set for January 1, 2026 | 72 hours for expedited requests, seven calendar days for standard requests |
| Prior Authorization API and FHIR-based API requirements | Compliance date set for January 1, 2027, moved from an earlier January 1, 2026 target | Impacted payers implement and maintain the API |
| Annual public reporting of prior authorization metrics | Annual reporting cycle | Approval and denial rates, approval-after-appeal rates, average and median submission-to-decision times |
The API layer carries its own scope. The rule requires a Prior Authorization API that identifies whether authorization is needed, exposes documentation requirements, and exchanges requests and decisions. It sits alongside three other exchange patterns the rule covers: Patient Access, Provider Access, and Payer-to-Payer. CMS has already pushed the general API compliance dates from January 1, 2026 to January 1, 2027, per the CMS implementation guides and standards page, so any date hardcoded into a roadmap is a bet on a moving target.
Slipping dates have a human cost. In the American Medical Association's 2023 physician survey, 94% of physicians reported that prior authorization was associated with delays in patient care, according to the AMA's analysis of how prior authorization disrupts care. A slower API widens that gap, which is why deadline-aware escalation and exception handling deserve release capacity ahead of cosmetic work on the submission form.
Build order: deadline clocks first, the interoperable submission path second, public reporting third.
Teams outside the US face different rules on similar architecture. A product built for the Netherlands, the wider EU, the UK or Canada can reuse the state model and the audit trail, while the deadlines come from local regulators.
The Da Vinci CRD, DTR and PAS Guides in Plain Terms
Da Vinci is an HL7 community effort that publishes FHIR implementation guides for payer and provider exchange. Three of its guides split the prior authorization path into three separate conversations, and separating them is what makes each one testable.
CRD is the question asked while the clinician is still ordering. DTR is the form that collects exactly the fields the payer wants. PAS carries the request out and the decision back.
| Guide | Question it answers | When it runs | Connects with |
|---|---|---|---|
| CRD (Coverage Requirements Discovery) | Does this order need prior authorization, and what does the payer require? | At order entry | EHR through CDS Hooks |
| DTR (Documentation Templates and Rules) | Which questions and attachments must the documentation contain? | During documentation | EHR through SMART on FHIR apps |
| PAS (Prior Authorization Support) | How is the request submitted, and how is the decision returned? | At submission and status checks | Payer through FHIR bundles, with X12 278 via an intermediary where required |
CRD runs on CDS Hooks. The EHR fires a hook at order entry, the payer’s service replies with whether authorization is required and which documentation rules apply, and the answer arrives before the order is signed. Timing is the whole value here, since a requirement discovered after submission becomes a resubmission.
DTR launches a SMART on FHIR app from inside the EHR. The app renders the payer’s questionnaire, prefills what the record already supports, and returns a completed response. A well-built DTR shows the clinician the gaps and hides the rest of the form.
PAS carries the finished request as a FHIR bundle and brings back a decision the provider system can read into the record. Our FHIR and HL7 integration guide goes deeper into the resource model underneath all three.
Run these checks with each payer before you commit to a launch date:
-
Supported guide versions: Which versions of CRD, DTR, and PAS the payer has published and tested against.
-
Capability statement and endpoints: Whether the payer publishes a current capability statement, and whether the sandbox behaves like production.
-
Fallback channel: Which route applies when the API is down, returns an unexpected shape, or answers outside the deadline.
Architecture for a Multi-Payer SaaS Platform
A request moves through six components, and their order decides where your failures surface. Build this as a continuing interoperability operation, not a one-time integration: every payer connection keeps drifting, and the architecture has to absorb that drift without losing the thread of any single request.
The EHR integration layer reads Patient, Coverage, Encounter, Condition, MedicationRequest, and ServiceRequest resources over FHIR R4 and stores provenance for every value it lifts. When a reviewer asks where a diagnosis came from, you want the resource and its version.
The requirements service holds payer coverage rules. CRD responses from CDS Hooks at order entry populate it, and a versioned cache covers payers that don’t answer in time. Versioning matters here, because a cached rule has to be identifiable as stale before it sends a request down the wrong path.
The documentation module runs as a SMART on FHIR app launched from the EHR, so the clinician works inside their own record while the payer’s questionnaire renders beside it.
The submission router decides the path. It builds PAS bundles for payers with working APIs, sends X12 278 through an intermediary where a payer requires it, and falls back to a portal where neither is available. The status service and audit service close the loop by recording what came back and when. That record is what lets a deadline clock attach to each request, and it is what a dispute or audit will ask for later.

Two formats, one event stream. The HL7 Da Vinci PAS implementation guide supports ASC X12N 005010X217, the Health Care Services Review transaction commonly called the X12 278, alongside the FHIR workflow. In the standard pattern, a provider system assembles the clinical and administrative content in a FHIR bundle and sends it to an intermediary, which converts it to X12 278 when required before forwarding it to the payer, with responses travelling the same path in reverse. Your status service therefore reads both formats and normalises them into one timeline of submitted, acknowledged, pended, determined, and appealed events.
The decision record needs typed fields. The Prior Authorization API response carries approval or denial status, the authorization’s expiration date or ending circumstance, and specific denial reasons. Store those in typed columns with a controlled vocabulary, because a denial reason pasted into a free-text note defeats the reporting you will need later.
Count the cost of keeping this accurate. Payers change questionnaires, medical policies, and capability statements, and a path that was validated in March can be stale by September. Our healthcare integrations work covers validation, monitoring, audit logging, and secure error management, which is the operational layer a payer registry depends on. The healthcare API integration playbook covers the field mapping and versioning decisions that break first.
Where AI Helps and Where Human Review Stays
The boundary comes from the regulator. The FHIR Prior Authorization API is not required to make real-time decisions, per the CMS FAQ on improving prior authorization processes, so some requests will still need clinical review. Design for that before anyone evaluates a model.

The volume justifies the effort. Physicians report completing about 40 prior authorizations per week, consuming roughly 13 hours of physician and staff time, per the same CMS FAQ.
Where AI earns its place:
-
Document extraction: Turning faxed notes and PDFs into structured resources, with provenance recorded for each extracted fact.
-
Criteria matching: Comparing the documentation against payer policy text and naming the criterion that isn’t met.
-
Gap prompts: Telling staff what to collect before submission instead of after a denial.
-
Deadline ranking: Ordering the work queue by the clock attached to each request.
The review layer carries the accountability. Set confidence thresholds that route weak extractions to a person, run a queue for borderline and urgent cases, and log every override with the reviewer’s identity and reason.
The escalation path is a product decision. Choose it before anyone opens a model selection document.
Measure the model like any other component. Sample extracted documents against human-reviewed versions, and track the override rate month over month. A rising override rate is an early signal that a payer changed its policy.
Compliance Requirements for HIPAA, Audit Trails and Deadlines
Start with the Security Rule. 45 CFR Part 164, Subpart C of the HHS regulation requires access controls, audit controls, integrity protections, and transmission security for electronic protected health information, and each of those maps to a build decision in an authorization system.
The audit trail is the artifact reviewers ask for first. Record timestamped events for submission, payer acknowledgment, clinical information requests, determination, and appeal, with the user or system identity attached to each. Store the raw payload alongside the parsed event, because an auditor will ask what the payer sent, and not what your screen displayed.
Then the clock. Keep received, submitted, and due timestamps, derive the due time from the request’s urgency, and alert staff well before the deadline passes. Report turnaround as a median and a mean separately, since a handful of stalled exceptions can drag the mean far away from what most cases experience.
Practical rule: if a field can appear in a regulator’s report or an auditor’s sample, give it a typed column, a validation rule and a retention period.
For readers in the Netherlands, the wider EU and the UK, health data sits in the special categories of GDPR and UK GDPR, which raises the bar on lawful basis and retention well above the US baseline. In Canada, check PIPEDA alongside provincial health privacy law. Have counsel confirm the mapping for each market. Our guide to HIPAA-compliant software development covers the engineering controls in more depth.
Build Checklist and KPIs to Track After Launch
Work through the checklist in order, and don’t start at step four.
-
Map the demand: Sort requests by payer, service category, and urgency so each queue carries its own clock.
-
Read the capability statement: Confirm the Da Vinci guide versions and endpoints each payer supports.
-
Test conformance and contracts: Build tests per payer endpoint and rerun them on every release.
-
Build the fallback: Keep a working channel for payers without API support.
-
Instrument the audit trail and clocks: Timestamp every state change from day one.
-
Stand up the review queue: Include override logging and a reviewer-facing explanation of why a case was escalated.
-
Budget for interoperability operations: Payer rule changes, clinical policy validation, and security review are recurring work with a recurring cost.

Measure these against your own baseline, not a published benchmark:
-
Turnaround time, reported as median and mean against each request’s deadline.
-
Auto-approval rate, meaning the share of requests decided without staff involvement.
-
Denial rate by payer and by denial reason.
-
Avoidable resubmission rate, which shows how much first-pass documentation is missing.
-
Reviewer override rate, your best signal on extraction quality.
-
Documentation completeness at first submission.
Rebuild any business case from your own transaction volumes. The healthcare revenue cycle automation guide shows how the same event data feeds billing and denial management downstream.
Conclusion
Prior authorization automation holds up when a team runs it as a continuous interoperability operation. Payer rules change, clinical policies get revalidated, and the event model has to keep accurate state across every release. Assign every workflow stage an owner, then design against the decision clocks, because those timeframes shape the data model, the queues and the alerts your staff receive.
Support the Da Vinci PAS path and the X12 278 side by side, since some payers still route the X12 transaction through an intermediary. Keep AI in an assistive role: clinicians decide borderline and urgent cases, and every override gets recorded. Capture audit events from the first release, because HIPAA obligations and public reporting both depend on them.
Confirm every CMS date on cms.gov before you plan against it, and have counsel check the regulatory mapping for the Netherlands, the EU, the UK, or Canada. Teams scoping a payer mix and the integration work behind it can review our custom healthcare software development practice.
Frequently Asked Questions
Does CMS-0057-F apply to products sold in the Netherlands, the EU or the UK?
No. The rule governs US payers such as Medicare Advantage organizations, Medicaid and CHIP programs, and federally facilitated Exchange plans, so a European product answers to local regulators instead. The architecture carries over well, while the deadlines have to come from your own market.
Do we still need X12 278 if we build FHIR PAS?
Often, yes. The Da Vinci PAS guide supports ASC X12N 005010X217 alongside the FHIR workflow, and some payers still require the X12 278 transaction through an intermediary. Keep one internal event model and two transports.
Can automation approve requests without a clinician?
Only for cases your rules can settle cleanly. CMS states the FHIR Prior Authorization API is not required to make real-time decisions, so borderline, incomplete, and urgent requests need review. Route those to a named reviewer with logged overrides.
What turnaround times apply to standard and expedited requests?
For non-drug items and services, impacted payers must decide expedited requests within 72 hours and standard requests within seven calendar days. Confirm the current scope on cms.gov before you hard-code a deadline rule into a product.
Which KPIs should we start with?
Start with median and mean turnaround against each request’s deadline, denial rate by denial reason, and reviewer override rate. Together they tell you whether submissions are clean, the queue is honest, and extraction is holding up.
Bridge Global builds HL7, FHIR, and DICOM integrations for healthtech and provider platforms, with validation, monitoring, audit logging, and secure error management built into the delivery. To discuss your scope, schedule a call with the team at Bridge Global.