# How to Validate Health Plan Eligibility Files Before They Load

**Published:** Nov 18, 2026
**Author:** Donal Tobin
**Category:** Eligibility file

## Summary

An 8-step guide to validating health plan eligibility files before they load: file checks, structure, field and duplicate rules, comparison with the last delivery, and routing rows to load, hold or reject.


![How to Validate Health Plan Eligibility Files Before They Load](https://cdn.buttercms.com/jJT2HPYXTd4jcFcy5vAa)


## Content

To validate a health plan eligibility file before it loads, check the file as a whole first, then its structure, then every field and row, and compare it with the plan's previous delivery before deciding what loads, what waits for review and what gets rejected. This guide is for data and engineering leads at companies that receive member eligibility files from health plans and employers, and for the operations teams who handle the exceptions. By the end, you will have a validation layer that stops bad files at the door while letting clean members through.

Validation is the step that decides whether a bad delivery becomes a five-minute fix or a week of cleanup in production.

## The Problem: Bad Eligibility Data Gets Loaded Quietly

Eligibility files fail in ways that don't look like failures. A plan sends last month's file again, a blank file, or a file where the date column switched format. A partial file loads without errors and silently terminates thousands of members who are still covered. Duplicate member IDs create two records for one person.

Most pipelines only check whether a file could be parsed. If it parses, it loads. The problems surface later, when a member can't be served, an invoice is wrong or a report doesn't match the plan's numbers. Validation moves those checks to the moment the file arrives.

## What You'll Need Before Starting

* The plan's file specification or 834 companion guide, including required fields and allowed codes
* Your standard member schema and the field mapping for this plan (see how to onboard a new health plan's eligibility file)
* The plan's previous delivery, or a recent sample, for comparison checks
* A review table or folder where held rows and rejected files will go
* An alert channel the operations team watches

## How to Validate a Health Plan Eligibility File: Step-by-Step

### Step 1: Write Down What "Valid" Means for This Plan

Rules that live in someone's head get applied inconsistently. A written validation spec makes every check explicit and reviewable.

**What to do:**

- List file-level rules: expected name pattern, delivery window, encryption, minimum size

- List structural rules: required columns, column order or header names, delimiter

- List field rules: required fields, formats, allowed values such as relationship and coverage codes

- Decide the action for each rule: reject the file, hold the row or log a warning

**Output of this step:** A validation spec for the plan, with an action attached to every rule.

### Step 2: Check the File Before Reading a Single Row

The cheapest checks run on the file itself. They catch wrong, empty and stale files before any member data is touched.

**What to do:**

- Confirm the file name matches the plan's pattern and the expected delivery date

- Reject empty files and files far below the plan's usual size

- Confirm PGP-encrypted files decrypt cleanly

- For 834 files, check the control segments: the SE, GE and IEA trailers carry counts that should match the content

- Compare a checksum with the previous file to catch a resend of the same delivery

**Output of this step:** Only files that look like a genuine new delivery move on.

### Step 3: Validate the Structure Against Your Mapping

A file can be the right file and still have the wrong shape. Structural checks catch renamed, missing and reordered columns before they shift data into the wrong fields.

**What to do:**

- Compare the header row with the expected column names, allowing only the variations you mapped

- Confirm the column count on every row, which catches stray delimiters inside values

- Check that each column holds the expected data type, such as dates in date fields and numbers in ID fields

- Reject the file if a required column is missing entirely

**Output of this step:** Confirmation that the file's layout still matches your mapping.

### Step 4: Validate Every Field and Row

Field checks find the individual records that would break downstream systems. Most belong at row level, so one bad record doesn't stop a whole delivery.

**What to do:**

- Require member ID, name, date of birth and coverage start date on every row

- Check formats: dates parse correctly, phone numbers have the right number of digits, IDs match the expected pattern

- Check allowed values, such as relationship codes and coverage tiers, against the plan's code list

- Check date logic: coverage end is after coverage start, and dates of birth are not in the future

**Output of this step:** Every row marked as passing or failing, with a reason for each failure.

**Where Integrate.io helps:** Field checks are built with 220+ low-code expressions, and the data previewer shows the effect of each rule on real rows before the pipeline runs, so rules can be tested against a sample file before they touch production.

### Step 5: Catch Duplicates and Conflicting Records

A member who appears twice can be served twice, billed twice or terminated by mistake. Duplicate checks need their own step because they compare rows with each other.

**What to do:**

- Flag rows that share a member ID within the same file

- Flag rows that share a name and date of birth but have different member IDs, which often signals a re-enrollment

- Where a plan sends related files, such as a member file and a dependents file, confirm each row matches a record in the other file

- Hold every conflicting row for review instead of guessing which one is correct

**Output of this step:** Duplicates and conflicts separated from clean rows, ready for a person to resolve.

### Step 6: Compare the File With the Previous Delivery

Some of the most damaging problems only show up in comparison. A file can pass every field check and still be incomplete.

**What to do:**

- Compare the row count with the previous delivery and flag changes beyond a set threshold, such as 10 percent

- Count terminations: a sudden spike usually means a partial file, not mass disenrollment

- Count new members and changed records, and flag unusual jumps for review

- Hold the whole file for review when a comparison check fails, rather than loading it

**Output of this step:** Confidence that the file is complete, or a clear flag that it may not be.

### Step 7: Route Results: Load, Hold or Reject

Validation is only useful if every result has a destination. Clear routing means nothing is dropped and nothing is loaded by accident.

**What to do:**

- Load rows that passed every check into the destination

- Send held rows to a review table with the rule that failed and the source file name

- Move rejected files to a quarantine folder and keep the original unchanged

- Record a run summary: rows received, loaded, held and rejected

**Output of this step:** Every row accounted for, either loaded, held for review or rejected with a reason.

**Where Integrate.io helps:** A filter component splits rows inside the pipeline, so invalid records go to a separate destination for manual review while clean records continue to the database or warehouse.

### Step 8: Report and Alert on Every Run

The operations team needs to know what happened without opening the pipeline. A short report per run turns validation results into action.

**What to do:**

- Send a run summary after each delivery: counts loaded, held and rejected

- Alert immediately when a file is rejected or a comparison check fails

- Include the plan, file name and the failed rule in every alert

- Review held rows on a fixed schedule so they don't pile up

**Output of this step:** A team that sees every validation problem the day it happens.

**Where Integrate.io helps:** Job logs show each run's failed records with an error summary, and notifications send failures to email or a Slack channel, so the right people hear about a rejected file right away.

## Common Mistakes to Avoid

* Validating only that a file parses (step 2): a blank file or a resent file parses fine. Check the file itself before its rows.
* Rejecting a whole file for a few bad rows (step 4): hold the failing rows and load the rest, unless a file-level or comparison rule fails.
* Guessing which duplicate is right (step 5): automated picks create silent errors. Hold conflicts for a person to resolve.
* Skipping the comparison with the last file (step 6): partial files pass every field check. Row counts and termination spikes catch them.
* Letting held rows pile up (step 8): a review queue nobody checks is the same as dropping the data. Assign an owner and a schedule.

## Conclusion

Validating a health plan eligibility file before it loads comes down to eight steps: write the rules, check the file, check the structure, check every row, catch duplicates, compare with the last delivery, route the results and report on every run. Each step stops a different kind of bad data, and together they let clean members through while holding back the rows that need a person. Integrate.io covers the mechanics, from low-code field checks tested in the previewer to routing invalid rows for review and alerting on failures, so the team spends its time fixing data issues rather than finding them. For the full onboarding process this fits into, see [how to onboard a new health plan's eligibility file without building a new pipeline](https://www.integrate.io/blog/how-to-onboard-health-plan-eligibility-files/).

## Frequently Asked Questions

### What are the most common errors in health plan eligibility files?

The most common are missing required fields, inconsistent date formats, duplicate member IDs, invalid relationship or coverage codes and coverage end dates before start dates. At file level, the most damaging are blank files, resent files and partial files that look complete.

### Should you reject a whole eligibility file or just the bad rows?

Reject the whole file when the problem is the file itself: it's empty, a resend, structurally wrong or fails a comparison check. When only some rows fail field or duplicate checks, hold those rows for review and load the clean ones.

### How do you catch a partial eligibility file?

Compare each delivery with the previous one. A row count far below normal, or a sudden spike in terminations, usually means the file was cut off. Hold the file for review instead of loading it.

### How do you validate an 834 file before loading it into a warehouse?

Parse the 834 into rows first, then run the same checks as any eligibility file: required fields, formats, allowed codes, duplicates and comparison with the previous delivery. The 834's control segments add one more check, since their counts should match the content.


## Tags

834 files, Data pipelines, Data validation, eligibility files, en, Healthcare data integration

## Categories

Eligibility file