Log inStart free

Industry packs

Automotive industry pack

Synthetic vehicle, warranty, recall, telematics and finance test data with linked masking

Self-service activation · in the Free Trial Version 1.1.0 · Complete

The full Automotive 1.1.0 journey — from the public pack page through the synthetic sandbox, signup, activation, agent and source setup, scenario, masking and subsetting, certification and provisioning to evidence export — was verified end to end on a local real-component stack (the real control plane, agent, engine, sandbox runner, website and console built from source, with synthetic data) on 2026-10-09. It becomes available to customers once a published agent release reports its installed packs and ships this pack version.

Try with synthetic dataActivate this pack — start free

No call and no credit card needed. Prefer a conversation? Request a demo (optional). Missing something? Request a feature.

Included in the Free Trial; no paid plan includes it yet. You can activate it for your organization yourself in the console; no call is needed.

Problems this pack solves

Masked data that still joins across 5 systems

9 cross-system relationships link crm, dms, finance, oem_warranty and telematics; the pack's masking keeps one pseudonym per identity on every side. For example, crm.owners.owner_id and dms.vehicles.owner_ref get the same pseudonym.

The cases production samples rarely contain

8 ready-made scenarios generate them on demand, for example: safety recall campaigns that have not been remedied on the affected vehicles; warranty claims rejected by the manufacturer, each with a rejection reason; diagnostic and service odometer readings that decrease over time (rollback suspicion).

Sensitive fields found and masked before anyone sees them

44 columns across 12 entities are classified (direct identifier, financial, PII, quasi identifier and sensitive) and covered by 3 masking templates you review and approve.

Evidence that each dataset is fit to use

2 certification presets check masking coverage, referential integrity, orphans and row counts before a dataset can be provisioned; a failed dataset is never provisioned.

Entities and relationships

12 entities across 5 source systems, generated from the pack’s own entity model.

Entity graph of the Automotive pack12 entities in 5 systems (crm, dms, oem_warranty, telematics, finance) linked by 17 relationships, 9 of them across systems. The table after the graph lists every relationship.crmdmsoem_warrantytelematicsfinanceOwner (crm.owners)Ownercrm.ownersDealer (dms.dealers)Dealerdms.dealersVehicle (dms.vehicles)Vehicledms.vehiclesVehicleSale (dms.sales)VehicleSaledms.salesRepairOrder (dms.repair_orders)RepairOrderdms.repair_ordersPart (oem_warranty.parts)Partoem_warranty.partsWarrantyClaim (oem_warranty.warranty_claims)WarrantyClaimoem_warranty.warranty_…Recall (oem_warranty.recalls)Recalloem_warranty.recallsRecallVehicle (oem_warranty.recall_vehicles)RecallVehicleoem_warranty.recall_ve…Trip (telematics.trips)Triptelematics.tripsDiagnosticEvent (telematics.diagnostic_events)DiagnosticEventtelematics.diagnostic_…FinanceContract (finance.finance_contracts)FinanceContractfinance.finance_contra…
Arrows point from the referencing entity to the one it references. Solid: a foreign key inside one system. Dashed: a cross-system relationship — the pack keeps the same pseudonym on both sides, so masked data still joins.
All 17 relationships as a table
Relationships of the Automotive pack
EntityReferencesColumnsKind
VehicleDealerdealer_code → dealer_codeWithin a system
VehicleSaleVehiclevin → vinWithin a system
VehicleSaleDealerdealer_code → dealer_codeWithin a system
RepairOrderVehiclevin → vinWithin a system
RepairOrderDealerdealer_code → dealer_codeWithin a system
WarrantyClaimPartcausal_part → part_numberWithin a system
RecallPartpart_number → part_numberWithin a system
RecallVehicleRecallrecall_code → recall_codeWithin a system
VehicleOwnerowner_ref → owner_idAcross systems (pack relationship template)
VehicleSaleOwnercustomer_ref → owner_idAcross systems (pack relationship template)
WarrantyClaimVehiclevin_ref → vinAcross systems (pack relationship template)
WarrantyClaimRepairOrderrepair_order_ref → repair_order_noAcross systems (pack relationship template)
RecallVehicleVehiclevin_ref → vinAcross systems (pack relationship template)
TripVehiclevin_ref → vinAcross systems (pack relationship template)
DiagnosticEventVehiclevin_ref → vinAcross systems (pack relationship template)
FinanceContractOwnerowner_ref → owner_idAcross systems (pack relationship template)
FinanceContractVehiclevin_ref → vinAcross systems (pack relationship template)

Realistic synthetic records

Synthetic data. Every record on this page is synthetic, generated from a fixed seed by the pack's own generator; masked values come from the real masking engine.

Owner — crm.owners (synthetic)
owner_id sensitivegiven_name sensitivefamily_name sensitivebirth_date sensitiveemail sensitivephone sensitivestreet_address sensitivecity sensitivepostal_code sensitivecountry_codedriving_licence sensitivemarketing_consentcustomer_since
OWN000000001OrenQuarrwick—oren.umberton1501@example.net555-001-23157511 Willowmere RowFarrowwick59698ZZDL-ZZ-5056435false2021-02-10
OWN000000002CeletteDunfield1972-11-02celette.morhart9861@example.org555-061-20987328 Mistral LaneLorrford79471ZZDL-ZZ-8944096true2021-07-08

Masking: before and after

Template Linked automotive test data (AUTO_LINKED_TEST_DATA) applied to a synthetic Owner record from crm.owners.

Synthetic Owner record before and after masking
ColumnClassified asBefore (synthetic)After masking
owner_idDirect identifierOWN000000001OWN325567091
given_namePII, Direct identifierOrenUlric
family_namePII, Direct identifierQuarrwickAshworth
birth_datePII, Quasi identifier—— (same value after masking)
emailPII, Direct identifieroren.umberton1501@example.netyoria.holloshaw314@example.org
phonePII, Direct identifier555-001-2315555-012-7535
street_addressPII, Quasi identifier7511 Willowmere Row3434 Duskwater Terrace
cityQuasi identifierFarrowwickMirelvale
postal_codePII, Quasi identifier5969855771
driving_licencePII, Direct identifierDL-ZZ-5056435NB-NH-7019851

Same pseudonym in two systems. The identifier OWN000000001 appears in crm.owners.owner_id and in dms.vehicles.owner_ref. Both become OWN325567091, so the masked systems still join (relationship AUTO_VEHICLE_OWNER).

Masked with a fixed public sample key so this example is reproducible; your data is masked with your own key, referenced from your secret store.

Synthetic scenarios you can run

10 runnable scenarios. Run any of them in the hosted synthetic sandbox, or preview them in your browser without an account.

Negative tests, kept apart. This scenario produces deliberately broken data for error handling and never passes certification as valid data:

  • AUTO_BROKEN_REFERENCES — Dangling cross-system references and invalid values for error-handling tests

Sample schemas and representative outputs

The schema the pack expects in each system (also as CREATE TABLE DDL in the downloads). A run produces a masked or synthetic dataset with the same tables, a certification report with the gates of the chosen preset, and an evidence manifest with checksums — the rows stay in your environment.

Owner — crm.owners · 13 columns

A person who owns or drives the manufacturer's vehicles (the natural subset root).

ColumnTypeRequiredSensitive classes
owner_id (key)VARCHAR(12)YesDirect identifier
given_nameVARCHAR(64)YesPII, Direct identifier
family_nameVARCHAR(64)YesPII, Direct identifier
birth_dateDATENoPII, Quasi identifier
emailVARCHAR(128)NoPII, Direct identifier
phoneVARCHAR(32)NoPII, Direct identifier
street_addressVARCHAR(128)NoPII, Quasi identifier
cityVARCHAR(64)NoQuasi identifier
postal_codeVARCHAR(10)NoPII, Quasi identifier
country_codeVARCHAR(2)Yes—
driving_licenceVARCHAR(16)NoPII, Direct identifier
marketing_consentBOOLEANYes—
customer_sinceDATEYes—
Dealer — dms.dealers · 3 columns

A franchised dealer (an organisation, not a person; its code stays unmasked).

ColumnTypeRequiredSensitive classes
dealer_code (key)VARCHAR(10)Yes—
dealer_nameVARCHAR(64)Yes—
regionVARCHAR(8)Yes—
Vehicle — dms.vehicles · 9 columns

A vehicle identified by its 17-character VIN, owned by a CRM owner.

ColumnTypeRequiredSensitive classes
vin (key)VARCHAR(17)YesDirect identifier
owner_refVARCHAR(12)YesDirect identifier
dealer_codeVARCHAR(10)Yes—
model_codeVARCHAR(8)Yes—
model_yearINTYes—
colourVARCHAR(8)Yes—
registration_plateVARCHAR(12)NoDirect identifier
first_registeredDATEYes—
odometer_kmINTYes—
VehicleSale — dms.sales · 8 columns

The retail sale of a vehicle to a CRM customer, possibly with a trade-in.

ColumnTypeRequiredSensitive classes
sale_id (key)BIGINTYes—
vinVARCHAR(17)YesDirect identifier
customer_refVARCHAR(12)YesDirect identifier
dealer_codeVARCHAR(10)Yes—
sold_onDATEYes—
sale_typeVARCHAR(6)Yes—
priceDECIMAL(12,2)YesFinancial
trade_in_vinVARCHAR(17)NoDirect identifier
RepairOrder — dms.repair_orders · 9 columns

A service visit at a dealer; warranty jobs are claimed from the manufacturer.

ColumnTypeRequiredSensitive classes
repair_order_no (key)VARCHAR(10)YesDirect identifier
vinVARCHAR(17)YesDirect identifier
dealer_codeVARCHAR(10)Yes—
opened_onDATEYes—
odometer_kmINTYes—
customer_complaintVARCHAR(400)NoSensitive
labour_amountDECIMAL(10,2)YesFinancial
parts_amountDECIMAL(10,2)YesFinancial
warranty_jobBOOLEANYes—
Part — oem_warranty.parts · 3 columns

A service part (invented part numbers; not personal data).

ColumnTypeRequiredSensitive classes
part_number (key)VARCHAR(10)Yes—
descriptionVARCHAR(64)Yes—
supplier_codeVARCHAR(8)Yes—
WarrantyClaim — oem_warranty.warranty_claims · 10 columns

A dealer's claim to the manufacturer for a warranty repair.

ColumnTypeRequiredSensitive classes
claim_id (key)BIGINTYes—
vin_refVARCHAR(17)YesDirect identifier
repair_order_refVARCHAR(10)YesDirect identifier
causal_partVARCHAR(10)Yes—
labour_opVARCHAR(10)Yes—
failure_dateDATEYes—
odometer_kmINTYes—
claim_amountDECIMAL(10,2)YesFinancial
statusVARCHAR(10)Yes—
rejection_reasonVARCHAR(24)No—
Recall — oem_warranty.recalls · 5 columns

A recall campaign remedying a defect on a population of vehicles (invented campaigns).

ColumnTypeRequiredSensitive classes
recall_code (key)VARCHAR(12)Yes—
titleVARCHAR(64)Yes—
severityVARCHAR(16)Yes—
part_numberVARCHAR(10)Yes—
announced_onDATEYes—
RecallVehicle — oem_warranty.recall_vehicles · 5 columns

A vehicle in a recall campaign and whether it has been remedied.

ColumnTypeRequiredSensitive classes
recall_vehicle_id (key)BIGINTYes—
recall_codeVARCHAR(12)Yes—
vin_refVARCHAR(17)YesDirect identifier
statusVARCHAR(16)Yes—
remedied_onDATENo—
Trip — telematics.trips · 10 columns

A connected-vehicle trip summary: where and when it started and ended, and how it was driven.

ColumnTypeRequiredSensitive classes
trip_id (key)BIGINTYes—
vin_refVARCHAR(17)YesDirect identifier
started_atTIMESTAMPYesQuasi identifier
ended_atTIMESTAMPYesQuasi identifier
start_gridVARCHAR(10)NoQuasi identifier
end_gridVARCHAR(10)NoQuasi identifier
distance_kmDECIMAL(8,1)Yes—
max_speed_kphINTNoSensitive
harsh_braking_eventsINTNoSensitive
harsh_acceleration_eventsINTNoSensitive
DiagnosticEvent — telematics.diagnostic_events · 7 columns

A diagnostic trouble code reported over the air (invented code set).

ColumnTypeRequiredSensitive classes
event_id (key)BIGINTYes—
vin_refVARCHAR(17)YesDirect identifier
dtc_codeVARCHAR(8)Yes—
occurred_atTIMESTAMPYesQuasi identifier
location_gridVARCHAR(10)NoQuasi identifier
odometer_kmINTYes—
severityVARCHAR(16)Yes—
FinanceContract — finance.finance_contracts · 12 columns

A loan, lease or balloon contract financing one vehicle for its owner.

ColumnTypeRequiredSensitive classes
contract_no (key)VARCHAR(13)YesFinancial, Direct identifier
owner_refVARCHAR(12)YesDirect identifier
vin_refVARCHAR(17)YesDirect identifier
productVARCHAR(8)Yes—
principalDECIMAL(12,2)YesFinancial
aprDECIMAL(5,2)Yes—
monthly_paymentDECIMAL(10,2)YesFinancial
start_dateDATEYes—
term_monthsINTYes—
statusVARCHAR(10)Yes—
payer_ibanVARCHAR(34)NoFinancial, Direct identifier
credit_bandVARCHAR(2)NoFinancial, Sensitive

Compatible connectors

Verified with this pack version: PostgreSQL and Local files (Parquet / CSV). 17 more connectors are compatible by capability: they support what the pack needs, but have not been verified with this pack yet.

ConnectorStatus with Automotive
Local files (Parquet / CSV)Verified with this pack
PostgreSQLVerified with this pack
Amazon S3 / S3-compatible storageCompatible by capability (not yet verified with this pack)
Apache Kafka (connector in preview)Compatible by capability (not yet verified with this pack)
Azure Blob Storage / Data Lake StorageCompatible by capability (not yet verified with this pack)
DatabricksCompatible by capability (not yet verified with this pack)
Generic SQL (SQLAlchemy)Compatible by capability (not yet verified with this pack)
Google BigQueryCompatible by capability (not yet verified with this pack)
HTTP APIs (connector in preview)Compatible by capability (not yet verified with this pack)
IBM Db2 (connector in preview)Compatible by capability (not yet verified with this pack)
Mainframe files (EBCDIC / copybook) (connector in preview)Compatible by capability (not yet verified with this pack)
MariaDBCompatible by capability (not yet verified with this pack)
Microsoft SQL ServerCompatible by capability (not yet verified with this pack)
MongoDB (connector in preview)Compatible by capability (not yet verified with this pack)
MySQLCompatible by capability (not yet verified with this pack)
Oracle DatabaseCompatible by capability (not yet verified with this pack)
Parquet filesCompatible by capability (not yet verified with this pack)
SnowflakeCompatible by capability (not yet verified with this pack)
SQLite (developer evaluation) (connector in preview)Compatible by capability (not yet verified with this pack)

Prerequisites and expected setup effort

You need

  • A DataNivra account; the Free Trial includes this pack.
  • One DataNivra agent inside your network (outbound HTTPS only) that ships Automotive 1.1.0.
  • Read-only access to a compatible source (verified with this pack: PostgreSQL, Local files (Parquet / CSV)).
  • A non-production target environment the agent may write test data to.
  • A masking key in your own secret store, referenced as vault://…, azure-kv://… or env://… (DataNivra only ever sees the reference).
  • For production sources, a second person who approves policies (separation of duties).

A DataNivra agent that reports its installed industry packs (releases after agent 0.3.0); the control plane runs a pack job only on an agent holding the exact active pack version with the catalogued integrity digest.

Expected setup effort (estimates)

StepEstimate
Try the synthetic sandbox
No install: sign up and open the sandbox.		Minutes (estimate)
Install (or reuse) the agent
One Docker command or a Helm chart; outbound HTTPS only.		Under an hour (estimate)
Connect a source
Register a read-only source through the existing connector workflow.		Under an hour (estimate)
Review and approve policies
Create drafts from the Automotive templates, review and approve them.		Under an hour (estimate)
First certified dataset
Run the first job; certification and evidence are produced automatically.		Minutes (estimate)

Certification presets in plain language

AUTO_STRICT

Every gate; full masking coverage; zero orphaned vehicles, sales, repair orders, warranty claims, recall rows, trips, diagnostic events or finance contracts; exact row counts. Default for masked automotive test data.

  • Masking coverage of at least 100% of sensitive columns
  • No orphaned child records
  • Empty-value ratio may rise by at most 5%
  • Row counts must match exactly
16 gates it requires
  • POLICY_COVERAGE: every sensitive column is covered by an approved policy
  • MASKING_COMPLETION: masking finished on every covered column
  • REFERENTIAL_INTEGRITY: every reference still points at an existing record
  • SCHEMA_VALIDATION: the output schema matches the source schema
  • DATA_QUALITY: empty-value ratios stay within the preset’s drift limit
  • ROW_COUNT_RECONCILIATION: row counts match the plan within the tolerance
  • ORPHAN_DETECTION: no child record lost its parent
  • PROVENANCE: every row is tagged masked or synthetic
  • MANIFEST: a manifest lists every output table with checksums
  • POLICY_VERSION: the exact approved policy versions are recorded
  • ENGINE_VERSION: the engine version is recorded
  • CHECKSUMS: output checksums are recorded for later verification
  • IDENTITY_CONSISTENCY: linked identifiers got the same pseudonym in every system
  • SOURCE_READ_ONLY: the source was only read, never written
  • EGRESS_GUARD: no row-level data left the agent
  • CONNECTOR_HEALTH: the connectors stayed healthy during the run

AUTO_SCENARIO_TESTING

Every gate, with slightly relaxed NULL-ratio drift for scenario datasets whose business states (open recalls without a remedy date, vehicles without connected services, sales without trade-ins) leave optional fields empty.

  • Masking coverage of at least 100% of sensitive columns
  • No orphaned child records
  • Empty-value ratio may rise by at most 15%
  • Row counts must match exactly
16 gates it requires
  • POLICY_COVERAGE: every sensitive column is covered by an approved policy
  • MASKING_COMPLETION: masking finished on every covered column
  • REFERENTIAL_INTEGRITY: every reference still points at an existing record
  • SCHEMA_VALIDATION: the output schema matches the source schema
  • DATA_QUALITY: empty-value ratios stay within the preset’s drift limit
  • ROW_COUNT_RECONCILIATION: row counts match the plan within the tolerance
  • ORPHAN_DETECTION: no child record lost its parent
  • PROVENANCE: every row is tagged masked or synthetic
  • MANIFEST: a manifest lists every output table with checksums
  • POLICY_VERSION: the exact approved policy versions are recorded
  • ENGINE_VERSION: the engine version is recorded
  • CHECKSUMS: output checksums are recorded for later verification
  • IDENTITY_CONSISTENCY: linked identifiers got the same pseudonym in every system
  • SOURCE_READ_ONLY: the source was only read, never written
  • EGRESS_GUARD: no row-level data left the agent
  • CONNECTOR_HEALTH: the connectors stayed healthy during the run

Activate it and create your first certified dataset

Seven steps in the console, each linked below. Nothing needs DataNivra staff.

  1. Activate the pack for your organization

    Activation checks your plan, the pack's integrity digest and its dependencies, then enables Automotive 1.1.0.

    Open pack activation in the console

  2. Install or reuse your agent

    One agent runs every pack you activate; it must report this pack version. Upgrade it if it does not.

    Install the agent in the console

  3. Connect a compatible source

    Start with a connector verified with this pack: PostgreSQL, Local files (Parquet / CSV).

    Connect a source in the console

  4. Create policies from the pack templates

    Create drafts from Linked automotive test data, Unlinked warranty and quality analytics extract, Linked test data without connected-vehicle location and driving behaviour; a second person approves them (separation of duties).

    Create policies from templates in the console

  5. Request your first dataset

    Choose a scenario such as Everyday ownership (AUTO_EVERYDAY_OWNERSHIP), the subset size and relationship closure.

    Request a dataset in the console

  6. Certify

    The run is certified against a preset such as AUTO_STRICT; a failed dataset is never provisioned.

    See certification evidence in the console

  7. Provision and keep the evidence

    Provision the certified dataset to a non-production target, download the evidence and schedule refreshes.

    Provision the dataset in the console

Downloads

Version 1.1.0, 68 files (208.3 KB), all synthetic and generated from the pack itself. Every file’s SHA-256 is listed in MANIFEST.json.

Start here (2)
Entity–relationship diagram (2)
Sample schemas (6)
Policy templates (9)
API, CLI, SDK and CI/CD examples (10)
Synthetic sample data (CSV, JSON, Parquet) (37)

Troubleshooting

The reason codes you can meet on the way, with the recovery step. Every code is also in the error-code catalog.

SANDBOX_PACK_NOT_OFFERED — Synthetic estate not offered
A requested synthetic estate (industry pack) is not available in the hosted sandbox. What to do: Start the sandbox with the default estates.
ENTITLEMENT_REQUIRED — Plan does not include this
Your plan does not include this feature or industry pack. What to do: Upgrade in Billing & Plan.
PACK_INTEGRITY_UNVERIFIED — Pack integrity not verified
This pack version was registered without an integrity digest, so it cannot be activated (fail closed). What to do: Ask your operator to re-register the pack catalogue with the current control-plane image (register-pack), then activate again.
PACK_DEPENDENCY_INACTIVE — Required pack not active
This pack depends on another industry pack that is not active for your organization. What to do: Activate the packs this pack depends on first, then activate it again.
AGENT_PACK_MISSING — No agent can run this industry pack
The job's agent does not report the pack (older agents report no packs at all), so the job was not sent. What to do: Upgrade the agent to a release that reports its installed packs and ships this pack, then run the request again.
AGENT_PACK_VERSION_INCOMPATIBLE — Industry pack version differs on the agent
The agent holds a different version of the pack than the one the job was approved for. What to do: Deploy an agent with the pack's active version, or roll the pack back in Industry packs.
AGENT_PACK_INTEGRITY_MISMATCH — Agent pack differs from the catalogue
The agent reports the pack's version with a different integrity digest than the catalogued one, so the job was not sent. What to do: Redeploy the agent from the official signed image for this release, then run the request again.
PACK_TEMPLATES_UNAVAILABLE — Pack templates not registered
This pack version was registered without its policy templates. What to do: Ask your operator to re-register the pack catalogue (register-pack); create policies manually meanwhile.
PACK_TEMPLATE_KEY_REF_REQUIRED — Masking key reference required
A selected template keeps identities linked across systems and needs your masking key reference. What to do: Provide key_ref, e.g. vault://your-vault/tdm-masking-key, then create the drafts again.
PACK_NOT_ENABLED — Industry pack not enabled
The industry pack is not enabled for this tenant. What to do: Enable the pack (if your plan includes it).

Frequently asked questions

Are the Automotive records on this page real?
No. Every record on this page is synthetic, generated from a fixed seed by the pack's own generator; masked values come from the real masking engine. The masking example uses a fixed public sample key; your own data is masked with a key from your secret store.
Can I activate the Automotive pack myself?
Included in the Free Trial; no paid plan includes it yet. You can activate it for your organization yourself in the console; no call is needed.
Which databases and files does the Automotive pack work with?
Verified with this pack version: PostgreSQL and Local files (Parquet / CSV). 17 more connectors are compatible by capability: they support what the pack needs, but have not been verified with this pack yet.
How long does a first certified Automotive dataset take?
Estimates, not guarantees — try the synthetic sandbox: minutes; install (or reuse) the agent: under an hour; connect a source: under an hour; review and approve policies: under an hour; first certified dataset: minutes.
Which test scenarios does the Automotive pack include?
10 runnable scenarios (everyday ownership, open recalls, rejected claims, odometer rollback and more), plus 1 negative-test scenario kept apart from valid data.
Do Automotive rows leave my network?
No. The DataNivra agent runs inside your environment: it reads the source, masks, subsets, generates and certifies there, and sends only metadata, aggregate counts and evidence to the DataNivra control plane (customer-resident processing, zero raw-production-data egress).

Learn the concepts, then come back to activate

Regulatory context

The Automotive pack covers data that laws and industry rules often treat as sensitive. It supports your privacy and governance programmes by keeping those records inside your environment and producing certification evidence; it does not, by itself, make any system or organisation compliant with any law, regulation or standard.

Try with synthetic dataActivate this pack — start free

No call and no credit card needed. Prefer a conversation? Request a demo (optional). Missing something? Request a feature.