Summary

• Fabricate 4.30 allows enterprise customers to maintain draft and previous project versions alongside one published version.
• Published local-database data is locked by default, giving teams a stable test dataset while newer versions continue to change.
• The release also adds a certificate option for self-hosted environments and changes how models are selected for freeform text generation.

Tonic.ai has added project versioning to its Fabricate synthetic-data platform, giving enterprise development teams a way to keep one stable dataset in use for testing while continuing to modify and experiment with newer versions.

Fabricate 4.30 allows a project to hold several draft versions, one published version, and previous versions that have already been published. Teams can promote an earlier version back into use or publish a draft, while data in a published local database is locked by default against additions and removals.

The release addresses an operational problem that appears once synthetic data moves beyond an individual developer experiment. Test datasets are useful partly because they provide controlled conditions, but those conditions become unreliable if the underlying data changes while several teams, automated tests, or demonstrations depend on it.

Versioning gives synthetic data more of the lifecycle controls already taken for granted around application code, infrastructure definitions, and database schemas. Development can continue without changing the dataset currently supporting a repeatable test environment.

Test data needs stability as well as realism

Fabricate generates synthetic relational databases, unstructured information, and mock APIs, either from descriptions supplied through its Data Agent or from existing schemas and data patterns. Tonic positions the product for software development, integration testing, AI training, and situations where real production information is unavailable or inappropriate to use.

Synthetic data can reduce dependence on sensitive customer or operational records, but replacing real data with generated information does not automatically create a reliable testing process. The generated environment still has to preserve relationships between records, cover relevant edge cases, and remain stable long enough for teams to determine whether a change in the application caused a change in the result.

If both the software and test dataset move simultaneously, failures become harder to reproduce. An automated test that passed yesterday might fail today because the application changed, because its underlying synthetic records changed, or because a newly generated edge case appeared that was absent from the previous run.

A published version provides one way to separate those variables. Teams can keep a known dataset available to continuous-integration systems or testers while developing another version that introduces new scenarios, schema structures, or distributions.

Prior versions can also be promoted again, giving teams a recovery path where a newly published dataset creates unexpected behaviour. That does not amount to a complete data-governance system, but it brings a familiar rollback concept into an area where generated datasets can otherwise be treated as disposable artefacts.

Synthetic data becomes shared infrastructure

The need for version controls reflects a broader maturation of synthetic-data tools. Generating plausible names, addresses, and transactions is relatively simple; maintaining a connected simulated environment that several engineering teams can depend upon is substantially harder.

Fabricate can generate relational data across interconnected systems, create unstructured documents and text, connect to live database schemas, and produce mock APIs. It also provides workflows that can be reused through automated pipelines, meaning the output can become infrastructure rather than a one-off file downloaded by a developer.

That changes the operational expectations around the data. Once a synthetic environment feeds automated tests, agent training, frontend development, demonstrations, or integration work, teams need to know which version they are using and when it changed.

The problem has a close parallel in software configuration. A development organisation would rarely accept application code changing silently underneath every test run, yet data used to exercise that code has historically been managed with less discipline, particularly where test environments are assembled from database copies or ad hoc scripts.

Synthetic generation also creates a new source of variability because AI-assisted tools can produce records dynamically rather than selecting them from a fixed production snapshot. That flexibility helps create new scenarios, but versioning becomes more important when teams need to reproduce the exact state that exposed a bug.

Enterprise deployment adds quieter controls

Tonic’s 4.30 release includes another change aimed at self-hosted enterprise deployments. Administrators can now specify a globally trusted certificate-authority file where outbound HTTPS traffic passes through infrastructure that intercepts and re-signs encrypted connections.

That feature is considerably less marketable than synthetic-data generation, but it reflects the reality of deploying modern developer tooling inside organisations with existing network controls. Enterprise software frequently has to operate behind proxies, inspection systems, custom certificates, and other security infrastructure that public-cloud demonstrations do not encounter.

Fabricate has also changed model selection for freeform text generation. Rather than choosing one model directly, users now select a category — Economy, Fast, Standard, or Premium — leaving another layer of abstraction between the user and the underlying model.

That can make model changes easier for the vendor to manage, although organisations using generated text for repeatable tests will need to watch whether changes in underlying models alter the characteristics of their data.

Versioning helps contain that uncertainty because a generated result can be published and held constant even if the mechanism used to create future data changes later. The test environment becomes an artefact with a lifecycle rather than simply the latest output from a generator.

For teams trying to give developers realistic data without copying sensitive production records into staging environments, synthetic generation offers an attractive alternative. Its usefulness at organisational scale, however, depends on ordinary controls around versions, permissions, reproducibility, integration, and recovery.

Fabricate 4.30 is a comparatively narrow software release, but project versioning pushes the product further into that operational layer. Synthetic data becomes considerably more useful when teams can depend on it staying still while the software around it continues to change.