VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

How Export Verification Works | Prove the File Is Complete, Readable and Fit for Its Intended Use

Three students study around open books and worksheets in a shared classroom.

Export verification works by checking whether the generated file is readable, complete enough for its purpose, semantically faithful to the source and usable by the intended receiver.

The export button can succeed while the export fails.

A file can open and still omit records.

Counts can match and relationships can still be broken.

Values can look correct until a spreadsheet rounds identifiers or changes dates.

A verification plan therefore needs more than one check.

This article is the third pillar of How Data Exports Fail.


The Core Idea: Verify the Claim the Export Is Supposed to Support

A migration export makes a different promise from a parent report.

A research dataset makes a different promise from a personal data download.

Verification begins by restating the purpose and scope, then choosing observations that could show the file is wrong.


Check That the File Exists and Opens

This is the minimum.

Confirm that the generated file can be downloaded or retrieved, is not zero bytes unexpectedly, is not corrupted and opens in an appropriate reader.

Do not stop here.


Check the Format

Confirm the file is actually the advertised format.

A .csv extension does not prove valid CSV.

A JSON file should parse as JSON.

An archive should open without errors.

Format validation catches structural failures before semantic checking.


Check the Manifest

A useful export manifest can record source system, generation time, scope, filters, schema version and expected counts.

Verification should compare the actual file with that metadata.

A manifest is evidence only if it is generated or maintained accurately.


Check Record Counts

Compare expected and actual records.

If the source scope contains 4,200 rows and the export contains 4,037, the difference needs explanation.

Counts are powerful for completeness and weak for identity.


Check Distinct Identifier Counts

A join can duplicate rows without changing the underlying number of entities.

Count both rows and distinct stable identifiers.

If 4,200 students produce 5,700 rows, that may be correct for an enrolment-level export, but the declared grain must explain it.


Check Key Sets

For migration or reconciliation, compare source identifiers with exported identifiers.

Missing keys reveal omissions.

Unexpected keys reveal scope leakage.

Set comparison is stronger than count comparison because equal counts can hide swaps.


Check Field Presence

Confirm every required column or property exists.

Also check that deliberately excluded sensitive fields are absent.

Verification should prove both inclusion and exclusion.


Check Data Types in the Actual File

A source integer may be exported as text.

That can be acceptable.

A long identifier exported as a floating-point number may not be.

Check representation against the serialization specification.


Check Null and Blank Behaviour

Compare a sample containing known nulls, blanks, zeros and not-applicable values.

If all become empty cells, semantic information has been lost.


Check Dates and Time Zones

Select examples near month boundaries, midnight and daylight-saving transitions where relevant.

The receiver should interpret them exactly as intended.

Singapore dates are simpler than multi-zone global timestamps, but mixed-source systems can still require explicit offsets.


Check Numeric Precision

Use known decimal and large-identifier examples.

Open them in the actual destination application.

A raw text file can preserve precision that a spreadsheet display later changes.

The handoff, not merely the raw export, must be tested.


Check Units and Percentage Scale

Select values whose interpretation would fail obviously if the scale were wrong.

A percentage of 0.85 versus 85 is an easy boundary test.

A duration of 60 seconds versus 60 minutes is another.


Check Character Encoding

Use multilingual names, punctuation and mathematical symbols.

A dataset that verifies only against English text has not tested its full character range.


Check Quoting and Embedded Newlines

Select free-text records containing commas, quotation marks and paragraph breaks.

Open the export in a standards-aware parser and the intended consumer.

One comment should remain one field.


Check Relationships

If exported records refer to related entities, verify that those related records or resolvable references exist.

Count orphans.

Sample parent-child links.

A file can contain every entity and still lose the graph.


Check Attachments

If attachments are in scope, verify actual file presence rather than only attachment metadata.

If only references are in scope, verify that the references are deliberate and usable.

Do not confuse the two.


Check Historical Versions

If history is in scope, verify that current and superseded versions can be distinguished.

Choose a record known to have changed and confirm that the expected version history appears.


Check Effective Period

Verify minimum and maximum dates, reporting period and cohort.

A perfect export of August data is wrong when the request was September.


Check Filters

Compare active filters against the export specification.

A status filter or saved segment should be visible in verification evidence.

Do not infer scope from the file alone when the generator used hidden application state.


Check Permission Boundaries

Confirm that the export includes only records and fields the operator was authorised to export.

Sensitive-data verification should inspect the actual file, not merely the screen that launched the export.


Check File Naming and Identity

A filename should distinguish the dataset from adjacent exports.

Verify version, period and generation date where they matter.

Avoid ambiguous data.csv files accumulating in one folder.


Check Completeness by Category

A total count may match while one category is missing and another duplicated.

Compare counts by class, status, subject, region or another meaningful dimension.

Distribution checks reveal systematic omissions.


Check Control Totals

Use aggregates expected to survive the export.

  • Sum of transaction amounts.
  • Count per assessment.
  • Distinct learner count.
  • Minimum and maximum dates.
  • Count of records with null values.
  • Count of published versus draft items.

Control totals provide an independent view of completeness.


Do Not Use the Same Bug to Verify Itself

If the exporter calculates a total, verification should ideally calculate the same total independently from the source or raw file.

Reading the exporter’s own success summary back to itself adds little evidence.


Round-Trip Testing

A strong interchange test imports the export into a safe test destination and checks whether the intended state can be reconstructed.

This is especially useful for migrations and machine-to-machine handoffs.

The round trip should not overwrite the live system.


Round Trip Is Not Always Required

A parent PDF or one-way analytics file may not need re-import.

Use a test proportional to purpose.

The principle is to demonstrate the receiver’s intended use, not force every export through the same ritual.


Test the Actual Destination Tool

If the receiver will open CSV in Excel, test Excel.

If an API will parse JSON, test the actual parser or representative validation environment.

Interoperability failures often occur at the consumption layer.


Check for Formula Interpretation Risks

Spreadsheet applications can interpret some cell values as formulas or transform text automatically.

When exporting untrusted free text into spreadsheets, follow the destination’s safe handling guidance and avoid assuming plain-looking text will remain inert.

The appropriate mitigation depends on the system and security context.


Check Compression and Packaging

If files are zipped, verify the archive opens, expected files are present and paths do not create ambiguity.

If encryption is used, confirm authorised recovery of the package without exposing keys in the verification report.


Check Pagination Completion

For API-generated exports, record page or continuation-token progress where possible.

The final page should end because the dataset ended, not because a request failed silently.


Check Rate-Limit Recovery

If export retrieval can be throttled, test whether retries resume correctly and whether duplicated or missing pages can occur.

The presence of a final file is not proof of clean pagination.


Check Repeated Export Reproducibility

Two exports from an unchanged snapshot should agree under the defined rules.

Unexpected differences can reveal nondeterministic sorting, time-dependent defaults or changing source state.


Check for Unintended Sensitive Data

Search for fields and patterns that should not be present.

Sample records manually.

Data minimisation is part of quality, not merely compliance.


Check for Missing Documentation

A technically perfect file can still be unusable when the receiver does not know field definitions, units or null conventions.

Verification should confirm that the schema or data dictionary travels with the file when needed.


Worked Example: Student Results

Expected: 500 result records from one term.

Verification checks 500 row keys, 500 distinct student-assessment-attempt combinations, score range, percentage derivation, counts by class and the period’s minimum and maximum dates.

A spot check then opens the CSV in the intended spreadsheet tool and confirms learner IDs retain leading zeros.


Worked Example: Writing Portfolio

Purpose: showcase final work.

Verification checks one final essay per selected assignment, expected student identifier, document readability and absence of internal tutor-only notes.

Revision history is intentionally absent because it was outside scope.


Worked Example: WordPress Export

Verification confirms expected post and page counts, publication statuses, category relationships and the documented fact that media are referenced rather than embedded.

A separate media export or migration step is checked if full media transfer is part of the target.


Worked Example: JSON API Export

Verification parses the JSON, checks schema version, confirms large IDs remain strings, validates timestamp offsets and compares source and exported identifier sets.

The test uses the same parser family as the downstream consumer where practical.


A Practical Export Verification Pack

  • Export purpose.
  • Source system and snapshot.
  • Scope and filters.
  • Schema version.
  • Expected record count.
  • Actual record count.
  • Distinct identifier comparison.
  • Required field check.
  • Sensitive-field exclusion check.
  • Critical value samples.
  • Control totals.
  • Category distributions.
  • Relationship/orphan checks.
  • Attachment check.
  • Encoding/precision/date tests.
  • Destination readability test.
  • Round-trip result if applicable.
  • Known limitations.
  • Release decision.

Verification Status

Passed

Defined critical checks agree and the intended use is demonstrated.

Passed with known limitations

The file is usable for the stated purpose, with explicit exclusions or accepted constraints.

Failed

A critical mismatch or unusable representation remains.

Incomplete

Required checks have not been performed.

Incomplete is not another word for passed.


Release the Export Only After the Right Checks

For low-consequence handoffs, this may be a small checklist.

For migration, financial, educational or sensitive data, the evidence may need formal review.

Scale the controls to consequence.


Verification After Fixes

If a defect is found, repair the generator or scope definition where possible.

Do not merely patch one output file and forget the repeatable process.

Regenerate and rerun the relevant checks.


Verification Over Time

Recurring exports can drift as schemas, permissions and source systems evolve.

Track repeated mismatches.

A new unknown field, falling count or changing null pattern may be an upstream change signal.


The Verification Test

  • Does the file open?
  • Does it parse?
  • Does the actual record set match scope?
  • Do stable IDs match?
  • Are required fields present and sensitive fields absent?
  • Are types, dates, time zones, units and precision preserved?
  • Are relationships reconstructable?
  • Does the intended destination tool read it correctly?
  • Do independent counts and totals agree?
  • Are limitations explicit?

Across the eduKate Ecosystem

This pillar follows naturally from How Import Reconciliation Works. Export verification proves the file faithfully represents the source for a purpose; import reconciliation later proves the target faithfully reflects the imported source under its mapping. How Checklist Verification Works provides the wider principle: a check must be capable of disagreeing with the original claim.


Sources and Further Reading

RFC 4180 — Common Format and MIME Type for CSV Files

RFC 8259 — JSON Data Interchange Format

W3C — Model for Tabular Data and Metadata on the Web

WordPress.com Support — Export Your Website’s Content


The Deeper Principle: The Receiver Must Be Able to Use What the Export Claims to Contain

An export is trustworthy when its scope, representation and evidence agree.

The right records are present.

The wrong records are absent.

Meaning survives the format.

Relationships remain understandable.

And the intended receiver can actually use the result.


Continue the Series

How Data Exports Fail | Why Complete-Looking Files Can Still Omit, Distort or Expose the Wrong Data

How Export Scope Works | Decide Which Records, Fields, Versions and Relationships Leave the System

How Export Serialization Works | Preserve Types, Delimiters, Encoding, Dates and Precision Across Formats

eduKateSG