WeXL Forge · Test · Blueprint

Forge Data

Generates synthetic test data and reconciles migrated data

Takes
Database schema (DDL) or data dictionaryData classification and masking rulesSource-to-target mapping for a migration
Gives
Synthetic data sets as SQL inserts or CSV, from a fixed seedReconciliation rules for sign-offBreak report, grouped, with a suggested cause for each group
Updated
Draft

The problem

Two jobs sit at either end of a migration, and both are usually done by hand.

Before it, teams need test data. The quickest source is a masked copy of production, and in a bank that copy is either not allowed or slow to approve. Masking also misses things: a free-text notes field, a column someone added last year. Hand-made data avoids the risk but is thin: a few well-behaved customers, none with a closed account, a joint holder or a currency the code treats differently. The defects that matter live in exactly those cases.

After a migration, someone has to show the data arrived intact. The usual answer is row counts and a few spot checks in a spreadsheet. Counts can match while amounts are rounded differently, dates shift by a day across a time zone, or a status code maps to the wrong value. Each break then takes an analyst a long time to trace, because nobody wrote down which rule should have applied.

Good looks like this: test data with the shape and the awkward cases of real data and no real person in it; and a reconciliation that checks every record against written rules, explains every break, and leaves a record an auditor can follow.

How it works

Forge Data is built on demand in your engagement. This is the approach we take.

For synthetic data, it reads your schema or data dictionary and your data classification rules. From the schema it takes types, keys and constraints. From the dictionary and the application code it proposes the business rules the data must respect: an account cannot close before it opens, a joint account has at least two holders, a dormant account has no recent transactions. A person confirms those rules. Then ordinary generators produce the rows, so volume and referential integrity come from code rather than from the model, and every data set can be regenerated from the same seed. The model’s job is the rules and the awkward cases worth covering; the rows themselves are generated deterministically.

For reconciliation, it reads the source-to-target mapping and both schemas, and drafts reconciliation rules: which fields must match exactly, which are transformed and how, what tolerance applies to amounts and dates. A person signs the rules off. The comparison itself runs as plain queries against both databases, inside your environment. Forge Data then groups the breaks, suggests the likely cause of each group (a mapping rule, a rounding difference, a time-zone shift) and points to example records that show it.

Every rule it proposes and every cause it suggests is for an analyst to accept or reject. It works from schemas, rules and only the break records you allow it to see, and customer data stays inside your environment.

Where it gets it wrong

  • It can propose a rule that is not true. A rule inferred from a column name or a code comment may be wrong for your business. That is why a person confirms the rules before any data is generated or any check is run.
  • Synthetic data misses what nobody wrote down. If a quirk of production is not in the schema, the dictionary or the code, it will not be in the synthetic data either. When later testing finds one, it goes back into the rules.
  • A plausible cause is not the cause. Its explanation of a group of breaks is a hypothesis. The analyst checks it against the records before closing the break.
  • Sensitive values can leak through samples. Break records shown to the model are masked first under your classification rules. In the strictest setups it sees only counts, field names and masked values.

Why not just prompt a chatbot

You could ask a chatbot for a hundred rows of test customers, or paste two query results and ask what differs. You would get rows with no referential integrity and no seed, and an explanation nobody can audit. Forge Data puts the model where it helps, proposing rules and explaining breaks, and leaves generation and comparison to deterministic code that runs inside your controls. The signed-off rules, the masking and the audit trail are the work.

What you get

  • In your engagement: we build Forge Data for your schemas and your migration, and your testers and data analysts sign off its rules instead of writing every check by hand.
  • Under your brand: services firms can offer it in their own migration and testing practice, with their own reconciliation templates.
  • Built to own: we build it against your databases and data classes, and hand over the source.

See three ways to use an agent.

Run it on your input.

Send us a real database schema or data mapping. We run Forge Data on it and send the output back within one working day, with a note on what we would change for your setup.

Start here

See Forge on your own codebase.

Start a conversationWe'll show the Live agents on a real workflow of yours.