Data exports fail when a file is created successfully but no longer represents the data the user thought they asked for.
The file may open. The rows may look tidy. The columns may have sensible names. The export button may even report success.
Yet the export can still omit records, include the wrong population, drop hidden relationships, flatten dates into ambiguous text, round identifiers, expose fields that should not have left the system, or preserve only references to attachments rather than the attachments themselves.
The mistake is to treat export as the opposite of import.
Export begins earlier.
Before a file is written, the system has already chosen which records are in scope, which fields survive, which version of each record is authoritative, which relationships are represented, and how internal state becomes an external format.
This master guide owns the general failure architecture. The three companion explainers go deeper into export scope, serialization and verification.
It does not replace eduKateSG’s specialised translation articles about spreadsheets, CSV handoffs, account-data export controls or WordPress-specific migration guidance. Those keep their specialised ownership. This cluster explains the broader mechanism of making data leave one system without silently changing what it means.
The Core Idea: Export Is a Controlled Projection of State
An export is a view of a larger system.
It may contain all records or a subset.
It may include every field or only selected fields.
It may represent current state, historical state, or the result of a query.
It may preserve relationships explicitly or reduce them to identifiers.
The exported file is therefore not the system itself.
It is a controlled projection.
Failure Mode 1: ‘Export All’ Does Not Mean Everything
A product may use the phrase ‘all content’ while still excluding themes, plugins, hidden configuration, media binaries, audit logs or system-managed metadata.
WordPress.com documents this distinction clearly: the standard content export includes posts, pages, comments, categories, tags and references to media, but not the media files themselves, themes, plugins or full site customisation.
The phrase all is always bounded by the export feature’s defined scope.
Failure Mode 2: Filters Remain Active
The user thinks they are exporting the full dataset.
A date filter, status filter, author filter, saved search or hidden segment remains active.
The export is perfectly correct for the active view and wrong for the intended job.
Export scope should be visible before the file is generated.
Failure Mode 3: Hidden Records Are Excluded
Systems often hide archived, deleted, inactive, private or soft-deleted records from normal views.
An export built from the visible list may silently omit them.
Sometimes that is correct.
Sometimes those records are necessary for audit, migration or historical analysis.
Visibility and export eligibility are separate decisions.
Failure Mode 4: The Wrong Time Window Is Exported
A file can contain correct records from the wrong month, term or reporting period.
The export succeeds.
The downstream analysis becomes misleading.
Business period should be part of the export identity.
Failure Mode 5: Current State Is Exported When History Was Needed
A migration may need the latest state only.
An audit may need change history.
A recovery archive may need several versions.
Exporting only current records can remove the evidence required for a different use.
Scope must match purpose.
Failure Mode 6: History Is Exported Without Version Meaning
A file contains several versions of each record.
Nothing identifies which one is current, superseded or effective at a given date.
The history exists but cannot be interpreted reliably.
Version status belongs in the export model.
Failure Mode 7: Relationships Become Orphaned IDs
A student record exports guardian_id = 9831.
The guardian table is not exported.
The number survives while its meaning disappears.
Relational exports need either the related entity, a resolvable external reference, or an explicit statement that the relationship cannot be reconstructed.
Failure Mode 8: Attachments Become Links
An export may preserve URLs or references to files rather than the files.
This can be exactly how the tool is designed.
It becomes a problem when the destination assumes the file itself is self-contained.
WordPress.com’s content export is an excellent teaching example because its XML references media rather than embedding the media library.
Failure Mode 9: The Export Includes Too Much
Coverage can fail by excess as well as omission.
A file prepared for one purpose may include personal, confidential or operational fields that the receiver does not need.
The safest export is not automatically the largest export.
Field minimisation and purpose belong in the scope decision.
Failure Mode 10: The Export Leaks Hidden Columns
A spreadsheet view hides a column.
The underlying export still includes it.
Visual hiding is not equivalent to export exclusion.
Sensitive-field checks should inspect the actual file.
Failure Mode 11: Display Labels Replace Stable Identifiers
A system displays ‘Secondary 1 Mathematics’ while internally using subject_id 241.
An export may include only the display label.
That may be readable for humans but unstable for machine matching.
A robust export often needs both stable identifiers and human-readable labels.
Failure Mode 12: Stable Identifiers Are Replaced by Row Numbers
Row 27 is not an identity.
Sort the file differently and row 27 becomes another record.
Exports intended for reconciliation or re-import should preserve identifiers that survive ordering changes.
Failure Mode 13: Spreadsheet Software Reinterprets Identifiers
A CSV contains 001234.
A spreadsheet opens it and displays 1234.
Another long numeric identifier may be shown in scientific notation or lose precision.
The export file may be correct while a downstream viewer changes the representation.
Verification should test the intended consumption path, not only the raw bytes.
Failure Mode 14: Dates Become Ambiguous
03/10/2026 means different things under different locale conventions.
Exporting a human-friendly date can create a machine-unfriendly ambiguity.
Use a declared unambiguous representation when the file is intended for interchange.
Failure Mode 15: Time Zones Disappear
A timestamp loses its offset.
The receiving system assumes local time.
Events move by hours.
Sometimes this changes the calendar date.
Serialization should preserve whether the value represents a global instant or a local wall-clock event.
Failure Mode 16: Decimal Precision Changes
A value stored with several decimal places is rounded for display and then exported from the display layer.
The file contains what the user saw, not the precision the system stored.
That may be appropriate for a report and wrong for a migration.
Export purpose should determine whether raw, rounded or formatted value is required.
Failure Mode 17: Percentages Change Scale
Internal storage 0.85 becomes display 85%.
The export emits 85 without metadata.
The receiver interprets 85 as 85.0 rather than 0.85.
Numbers require scale context.
Failure Mode 18: Nulls Become Empty Strings
The difference between unknown, not applicable, intentionally blank and zero can disappear in flat formats.
Once collapsed, downstream systems may not be able to reconstruct the original state.
Serialization choices must protect missing-value meaning.
Failure Mode 19: Boolean Values Become Ambiguous Text
True/False, Yes/No, 1/0 and Y/N can all represent boolean values.
A human reader can usually infer them.
A receiving system may not.
The export contract should define representation.
Failure Mode 20: CSV Quoting Is Broken
A comment contains a comma or line break.
The exporter fails to quote it correctly.
One logical field becomes several columns or records.
RFC 4180 exists precisely because these edge cases matter.
CSV looks simple until the data contain CSV punctuation.
Failure Mode 21: Character Encoding Corrupts Names and Symbols
English-only samples pass.
Chinese characters, mathematical symbols or accented names become corrupted.
The format may be structurally intact while the content is damaged.
Encoding belongs in the export specification.
Failure Mode 22: JSON Numbers Lose Intended Semantics
JSON has numbers, strings, booleans, null, arrays and objects.
It does not know that one number is a currency amount and another is a student identifier.
RFC 8259 also notes interoperability considerations around numeric precision.
Schema and documentation remain important even in a structured format.
Failure Mode 23: Field Names Change Across Versions
Version 1 exports student_id.
Version 2 exports learner_id.
The receiver still expects the old name.
The file is internally valid and incompatible with the consumer.
Export schema needs versioning when interfaces change.
Failure Mode 24: Column Order Changes
A downstream script maps columns by position.
The exporter inserts a new field in the middle.
Every following value shifts.
Where possible, consumers should map by stable field identity rather than assuming order, and exporters should document breaking changes.
Failure Mode 25: Derived Fields Are Exported Without Their Inputs
The file contains percentage but not raw_score or max_score.
The receiver cannot independently verify the calculation.
That may be fine for presentation.
It may be weak for audit or migration.
Choose exports according to the receiver’s next task.
Failure Mode 26: Raw Fields Are Exported Without the Derived Value
The opposite failure also occurs.
A downstream user expects the reported metric and receives only components.
They recreate the formula differently.
The export should include the agreed representation or a clear transformation rule.
Failure Mode 27: Sorting Changes Meaning
Some workflows depend on sequence.
An export reorders rows alphabetically.
The records are all present, but the intended sequence is lost.
If ordering is meaningful, preserve an explicit sequence field rather than relying on file position.
Failure Mode 28: Hierarchy Is Flattened Without Parent References
A nested category structure becomes one list of names.
Parent–child relationships disappear.
The export still contains every label.
The structure is gone.
Failure Mode 29: Duplicate Rows Are Introduced During Joins
A report joins one student to several enrolments.
Student-level values repeat on each row.
A user later sums a student field and double-counts.
The export needs a declared grain: what does one row represent?
Failure Mode 30: Aggregate Export Hides Record-Level Exceptions
A file contains class averages only.
The receiver assumes it can diagnose individual learner problems.
The export is not wrong; the use is wrong.
Scope should state the data grain and intended questions.
Failure Mode 31: Export Runs While Data Are Changing
The first half of the file reflects one system state and the second half a later state.
For many analytical exports that may be acceptable.
For migration or financial reconciliation it may not be.
The export method should define whether it represents one consistent snapshot.
Failure Mode 32: Pagination Drops Records
An API export retrieves page 1, page 2, page 3.
Data change during the process or the script mishandles the next-page token.
The final file is short.
Large exports need count and pagination verification.
Failure Mode 33: Rate Limits Produce Incomplete Files
An export script receives throttling responses and stops early.
It still writes a file.
The presence of a file is not evidence of completeness.
Completion logic must distinguish clean end-of-data from interrupted retrieval.
Failure Mode 34: Permissions Shape the Export Without Being Visible
Two users run the same export and receive different record sets because their permissions differ.
That can be correct.
The export should identify the scope or operator context when it matters to downstream interpretation.
Failure Mode 35: One User Exports Another User’s Restricted Data
The export function exposes fields or records beyond the operator’s legitimate purpose.
This is a serious scope and governance failure.
Export permissions should be checked as carefully as screen permissions.
Failure Mode 36: File Names Are Not Unique
Every monthly export is called data.csv.
Files are overwritten or confused.
The contents may be correct but provenance becomes weak.
Useful naming includes dataset, period, version or batch identity.
Failure Mode 37: Export Metadata Is Missing
The file lacks generation time, source system, filter state, schema version or record count.
Months later, investigators cannot tell what it represents.
A small manifest can dramatically improve interpretability.
Failure Mode 38: The Export Is Never Opened
The system says export complete.
Nobody confirms that the downloaded file can actually be read.
Compression errors, permission problems or corrupted downloads remain invisible.
At minimum, verify readability.
Failure Mode 39: Readability Is Confused With Completeness
A file opens perfectly.
Ten thousand rows are missing.
Readability is one property.
Completeness is another.
Failure Mode 40: Record Counts Match but Relationships Do Not
All students and guardians are exported.
The linking table is absent.
Every record count looks correct.
The family relationships cannot be reconstructed.
That is why export verification needs relationship checks as well as counts.
The Three Pillars of a Reliable Export
1. Scope
Define exactly which records, fields, versions, relationships and attachments leave the system. Read How Export Scope Works.
2. Serialization
Represent the selected data without changing type, precision, encoding, dates, nulls or structure. Read How Export Serialization Works.
3. Verification
Prove that the resulting file is readable, complete enough for its purpose and consistent with the source. Read How Export Verification Works.
A Practical eduKateSG Export Test
- Purpose — what will the receiver do with the file?
- Population — exactly which records belong?
- Filters — what date, status, owner or segment limits the export?
- Fields — which values leave, and which are deliberately excluded?
- Identity — which stable identifiers survive?
- Relationships — how will related records remain connected?
- History — current state only, or versions and audit history?
- Attachments — files, references or neither?
- Permissions — what can this operator legitimately export?
- Serialization — format, encoding, types, dates, units, nulls and precision?
- Manifest — source system, generation time, schema version and counts?
- Verification — which independent checks prove the file matches the intended source state?
- Destination — can the intended receiver actually use it?
Example: Student Results Export
A parent-facing report may need subject, assessment name, score, maximum score and teacher comment.
A migration export may also need stable learner ID, assessment ID, attempt number and raw dates.
Both are valid exports.
They serve different purposes.
Calling the parent report a migration-ready dataset would be the failure.
Example: Mathematics Error Analysis
A tutor exports an error log for analysis.
If the file contains only error labels but not question type, date or learner identifier, aggregate frequencies can be calculated but progression cannot be reconstructed.
The required scope depends on the analytical question.
Example: English Writing Feedback
A student portfolio export includes final essays but omits revision history.
That is sufficient for a showcase.
It is insufficient for studying how editing improved the writing.
Again, purpose defines coverage.
Example: WordPress Migration
WordPress.com states that its standard export file contains content and links to media rather than the media library itself.
That export is useful for content transfer.
A full-site migration has a broader scope.
The correct claim should match the documented mechanism.
Example: Spreadsheet Handoff
A CSV exports student IDs, names and percentages.
Opening it in a spreadsheet removes leading zeros from IDs.
The raw file may be fine.
The intended handoff is not.
Verification should therefore include the actual application used by the recipient.
Across the eduKate Ecosystem
This cluster continues naturally from How Data Imports Fail. Import owns source-to-target loading; export owns source-to-file projection. How Backup Coverage Works provides a useful comparison because backup and export both require explicit scope, but a backup is designed for recovery while an export may be designed for transfer, analysis, reporting or portability.
Sources and Further Reading
RFC 4180 — Common Format and MIME Type for CSV Files
RFC 8259 — The JavaScript Object Notation (JSON) Data Interchange Format
W3C — Model for Tabular Data and Metadata on the Web
WordPress.com Support — Export Your Website’s Content
WordPress.com Support — Export Your Media Library
The Deeper Principle: The File Is a Claim About the Source
Every export says something.
It says these records were selected.
These fields mean this.
This file represents this period and version.
These relationships survived.
This sensitive information was deliberately included or excluded.
A trustworthy export makes those claims visible enough to test.
Choose scope deliberately.
Serialize without distortion.
Verify before handing the file to the next system.
