Tech Arch

Enterprise AI Solution

DataVeil

Customer exports are full of PII and secrets, which makes them unusable for AI training, development, and testing. Redacting them with <EMAIL_REDACTED> tokens destroys the data’s value — models trained on tokens learn tokens. DataVeil turns sensitive multi-format exports into realistic, training-safe synthetic data — and refuses to release anything it cannot prove is clean.

The core idea: realistic replacement, coherent identities, fail-closed release

Every detected value is replaced with a format-preserving synthetic: credit cards stay Luhn-valid, phone numbers stay dial-able in shape, SSNs land in the never-issued range, IPs land in reserved TEST-NET blocks. A central entity map guarantees the same real person becomes the same synthetic person across every file, format, and archive — and an independent verifier re-scans every output before it can ship.

REALISTIC

Replacements pass the same validators as real data — Luhn checksums, NANP number shapes, valid email structure — so downstream code and models see statistically natural data, never redaction scars.

COHERENT

John.Smith@Acme.com in a text file and john.smith@acme.com in a JSON export resolve to the same synthetic identity — relational structure survives anonymization intact.

FAIL-CLOSED

Unknown formats, undecodable files, verifier hits, surviving canary probes → quarantine, never release. There are exactly two outcomes and no third state. Refusing to guess is a feature.

What a run actually does

Real pipeline output. The same customer appears in a support ticket and a CRM record — note the identical synthetic identity in both, the Luhn-valid card, and the never-issued SSN range.

In — support_ticket.txt

Customer John.Smith@Acme.com
reports billing failure.
Card on file: 4111 1111 1111 1111
Phone: (415) 867-5309
SSN: 123-45-6789

Out — released

Customer gwen.harper@northwind-corp.example
reports billing failure.
Card on file: 4145 7226 8206 9411   ← Luhn-valid
Phone: (415) 829-2138               ← format kept
SSN: 972-34-1167                    ← never-issued range

Same person in crm_record.json — same synthetic identity

{ "customer": { "email": "gwen.harper@northwind-corp.example", "phone": "(415) 829-2138", "plan": "enterprise", "seats": 250 } }

Verified behavior

15/15

executable tests

Identity coherence across files and formats, determinism across runs, Luhn validity of synthetic cards, fail-closed quarantine of unknown formats, and canary leak detection — all pinned in code.

0 PII

at rest in the entity map

The map stores SHA-256 fingerprints, never raw values; generation is seeded by HMAC of the original. Destroy the key and the mapping is irreversible; reuse it and corpora stay consistent across runs.

0 deps

Python standard library only

No supply chain to audit before it touches sensitive data. One CLI, a per-file audit manifest of hashes and detections, and idempotent re-runs.

Python (stdlib only) Format-preserving synthesis HMAC-seeded determinism Recursive archive handling Independent output verifier Canary probes Audit manifest

System design

Every file ends in exactly one of two places — release or quarantine — and the verifier that decides shares no state with the scrubber it checks, so a scrubber bug cannot silently pass its own output.

Customer exports text · JSON · CSV nested archives Format router per-format handlers archives recurse unknown format → quarantine Layered detectors regex + validators Luhn · octet range emails · SSNs · keys Entity map SHA-256 fingerprints no raw PII at rest Synthesizer HMAC-seeded · format- preserving · deterministic Independent verifier full re-scan · only known synthetics pass · canaries QUARANTINE for human review, reason recorded RELEASE training-safe synthetic data + audit manifest any doubt provably clean fail-closed Per-file audit manifest wraps every run: content hash · status · detection counts · quarantine reason · 15/15 executable tests

Built vs. designed

Built means running against real data with measured, test-pinned behaviour. Designed means the architecture and interfaces exist and the implementation does not yet. We would rather tell you which is which.

Capability Status Notes
Format-preserving synthesis — emails, cards (Luhn), phones, SSNs, IPs, API keys Built Deterministic regex + validator detectors; 15/15 tests
Identity-coherent entity map, no raw PII at rest Built SHA-256 fingerprints, HMAC-seeded generation, cross-run consistency
Fail-closed verifier, canary probes, recursive archives, audit manifest Built Two outcomes only: release or quarantine
NER detectors for names, addresses, organizations Designed Pluggable detector interface (Presidio / spaCy) feeding the same entity map
Parallel scale-out for millions of records Designed Two-pass: resolve identities once, rewrite in parallel; manifest already gives resumability
PDF handling — text-layer scrubbing, then in-place redaction Designed In-place redaction is the hard part: subset fonts, hidden layers, save history — verified by re-extraction through every route
OCR for scanned documents Designed Bounding-box paint-over with synthetic text; the output is re-OCR’d as the fail-closed check

The other half of the trust layer.

DataVeil makes sensitive data safe to put into AI systems; FactSpectra makes AI output safe to act on. Training data, dev/test environments, data sharing, compliance-bound corpora — if it has to be realistic and provably clean, this architecture applies.

Start a conversation →