How do I sign up for Tonic Fabricate and generate a relational dataset from a schema?

Most teams hit the same wall: you need a realistic relational dataset to build, test, or demo—but you don’t want to drag production data into yet another environment. Tonic Fabricate exists to break that tradeoff. You sign up in minutes, describe the schema or dataset you want, and let the Data Agent generate fully relational, production-shaped synthetic data from scratch.

This guide walks through, end to end, how to sign up for Tonic Fabricate and generate a relational dataset from a schema—so you can move from “we should test that” to “it’s already in staging” without touching sensitive data.

Quick Answer: Tonic Fabricate is an agentic synthetic data solution that lets you describe your relational schema (or ideal dataset) in natural language and generate fully relational, realistic test data on demand. You sign up via Tonic, access the Fabricate workspace, and use the Data Agent to define tables, relationships, and row volumes, then export to your preferred database or file format.

The Quick Overview

What It Is: Tonic Fabricate is a synthetic data generator that uses a Data Agent interface to create realistic, relational databases and unstructured files from scratch—no production data required.
Who It Is For: Engineering, QA, data, and AI teams that need production-like relational datasets for development, testing, demos, and model workflows without copying real customer data.
Core Problem Solved: You get realistic, referentially consistent test data when you don’t have safe access to production—and you don’t have time to handcraft fake data or maintain brittle SQL scripts.

How It Works

The workflow in Tonic Fabricate is intentionally simple: instead of hand-writing schemas and seed scripts, you describe what you want, and the Data Agent handles the heavy lifting—schema design, relationships, and realistic values—then outputs it in the structures your applications expect.

At a high level, you:

Sign up and access Fabricate: Create or join a Tonic account, get access to the Fabricate product, and open a new Fabricate project.
Define or import your schema: Describe your relational schema in natural language, paste a schema definition, or work iteratively with the Data Agent to model the right tables and foreign keys.
Generate and export synthetic data: Ask the Data Agent to populate your schema with realistic row counts and distributions, inspect the results, then export to your target environment (e.g., PostgreSQL, MySQL, or SQL scripts).

From there, you hydrate dev, staging, or demo environments with data that behaves like production—without the risk of moving sensitive data downstream.

Step-by-Step: Sign Up for Tonic Fabricate

If you’re starting from scratch, here’s the typical path to getting into Fabricate and ready to generate a relational dataset from a schema.

1. Create a Tonic Account

Go to tonic.ai.
Choose how you want to get started:
- Book a demo if you’re an enterprise team evaluating broader deployment across engineering and AI workflows.
- Start free (if available for your region/tier) to get hands-on with Fabricate in a trial environment.
Complete the sign-up flow:
- Provide your work email, name, and company.
- Set up authentication (password and/or SSO/SAML depending on your organization’s configuration).
- Confirm your email if prompted.

If your company already uses Tonic, you might be invited directly into your organization’s workspace by an admin.

2. Get Access to the Fabricate Workspace

Once in Tonic:

Navigate to the Products or Workspace area.
Select Tonic Fabricate from the product list.
If Fabricate isn’t enabled for your account:
- Contact your Tonic admin internally, or
- Reach out via Tonic’s email support or your account team to add Fabricate to your plan.

When Fabricate is enabled, you’ll see the Fabricate interface with options to create a new project and interact with the Data Agent.

3. Create a New Fabricate Project

Inside Fabricate:

Click New Project (or similar call-to-action like “Get started” or “Explore Tonic Fabricate”).
Name your project based on your workflow:
- ecommerce_relational_demo
- staging_customer_billing_schema
- model_training_user_events_synthetic
Optionally describe your goal (e.g., “Generate a relational dataset for a 5-table subscription billing schema for QA”).

This context helps you and your team track what each synthetic dataset is for and lets you re-run or iterate later without re-explaining the use case.

How to Generate a Relational Dataset from a Schema in Tonic Fabricate

Once you’re in a Fabricate project, the core workflow is collaborating with the Data Agent to define the schema and then generate data. Think of it as pairing with a synthetic data engineer that already understands relational modeling.

Phase 1: Define or Import Your Schema

You have a few patterns here, depending on whether you already have a schema or you’re designing from scratch.

Option A: Describe the Schema in Natural Language

If you’re starting net-new or want the agent to draft a schema for you:

Prompt example:

“Generate a relational customer database with:

A customers table (basic profile, email, signup date, plan tier).

An orders table referencing customers.

An order_items table referencing orders and products.

A products table with category, price, and inventory. Keep referential integrity across foreign keys and realistic distributions (e.g., 10% premium customers, skewed order frequency).”

The Data Agent will propose:

Table names and columns.
Data types and constraints.
Foreign keys across tables.

You can then review, accept, or refine (“Make customer_id a UUID,” “Add a nullable discount_code_id foreign key to orders,” etc.).

Option B: Paste an Existing Schema

If you have an existing schema definition (e.g., PostgreSQL, MySQL, SQL Server):

Copy the CREATE TABLE statements from your DDL.
Paste them into the Data Agent chat with instructions like:

“Here is my existing PostgreSQL schema. Use it as the source of truth and generate synthetic data that respects all primary/foreign key relationships and typical value ranges.”

The Data Agent will:

Parse table structures.
Infer relationships (if defined in the DDL).
Understand data types and constraints.

You can then ask it to adjust only where needed (“Treat status as an enum with values pending/complete/cancelled,” etc.).

Option C: Iterative, Table-by-Table Definition

For more control:

Define one table at a time.
Ask the agent to propose related tables and join patterns.
Explicitly define foreign keys.

Example:

“First, define a users table for a SaaS app with columns: id (UUID primary key), email, created_at, plan (free, pro, enterprise). Then define a subscriptions table that references users.id and includes status, start_date, end_date.”

This approach is useful when you want precise control over naming and relationships.

Phase 2: Configure Row Volumes and Relationship Cardinality

Once the schema is locked in, you need to decide how much data you want and how it should behave.

In the Fabricate Agent:

Specify row counts per table:
- customers: 50,000
- orders: 500,000
- order_items: 2,000,000
Define distributions and patterns:
- “10% of customers are premium; 60% of premium customers have orders in the last 30 days.”
- “Order totals follow a long-tail distribution with rare high-ticket purchases.”
Adjust relationship ratios:
- “On average, 5 orders per customer.”
- “Each order has 1–5 order_items.”

The Data Agent uses foundation models with domain knowledge to generate realistic values and patterns, not just random noise. That means:

Email formats look valid.
Dates line up (no end_date before start_date).
Foreign keys actually resolve.

You can ask the agent to show a sample of each table so you can iteratively tune the schema and distributions before generating the full dataset.

Phase 3: Generate, Inspect, and Export the Relational Dataset

With schema and volumes configured, you’re ready to generate and ship your data.

Instruct the agent to generate the dataset

For example:

“Generate the full dataset now with 100K customers, 1M orders, and 3M order_items, enforcing referential integrity across all tables.”

The agent will create:

Fully populated tables.
Correct primary/foreign key relationships.
Values that match your specified ranges and distributions.

Inspect data quality

Check:

Random samples from each table.
Foreign key integrity (e.g., every orders.customer_id exists in customers.id).
Edge cases you care about (nulls, extremes, special statuses).

If something looks off—say, not enough recent orders—you can adjust the prompt and regenerate until the behavior matches your expectations.

Export to your target format

Tonic supports exporting data in multiple formats. For relational datasets, typical paths are:

Database exports (via loaders or scripts):
- PostgreSQL
- MySQL
- SQL Server
- Oracle
SQL/CSV-based exports:
- Generated SQL insert scripts
- CSVs for each table
Other supported formats when you blend structured and unstructured artifacts:
- PDF
- DOCX
- EML
- PPTX

Choose the export that best matches your environment:

For staging/dev: export SQL or connect to your database target to load directly.
For demos or sandboxes: use smaller row counts and SQL or CSV dumps.
For AI workflows that combine schema + docs: pair your relational export with PDF/DOCX/EML artifacts generated by the same Fabricate project.

Now your team can hydrate environments with synthetic data that mirrors production complexity—without ever exposing real customer identities.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Data Agent interface	Lets you describe schemas and datasets in natural language.	Removes the need for hand-written DDL and seed scripts; non-DBAs can define complex schemas.
Relational data synthesis	Generates fully relational databases with enforced foreign keys and realistic values.	Test data behaves like production, keeping joins, constraints, and app logic working.
Multi-format export	Exports to relational targets (PostgreSQL, MySQL, SQL Server, Oracle) and formats like PDF, DOCX, EML, PPTX, SQL.	Integrates synthetic data into dev, QA, demos, and AI pipelines without extra conversion work.

Ideal Use Cases

Best for spinning up new test environments fast: Because Tonic Fabricate can generate entire relational datasets from a schema in a single workflow, you can hydrate staging or QA without waiting on production snapshots or approvals.
Best for building demo and sandbox environments: Because it creates realistic but entirely synthetic relational data, you can hand environments to customers, partners, or trainees without any risk of leaking real PII.

Limitations & Considerations

Doesn’t (by default) transform your live production database: Fabricate is designed for from-scratch synthetic data. If you need to de-identify and subset real production databases while preserving their exact structure and statistics, use Tonic Structural alongside or instead of Fabricate.
Complex domains may require iterative prompts: For highly specialized schemas or niche business rules, expect to refine prompts and review generated data. The Data Agent is powerful, but the best results come from treating it like a collaborator—not a one-shot generator.

Pricing & Plans

Tonic offers a product suite that includes Structural, Fabricate, and Textual, with pricing aligned to enterprise deployment and usage patterns.

For Tonic Fabricate:

You’ll typically start via a trial, POC, or enterprise subscription that unlocks Fabricate alongside other Tonic capabilities.
Exact pricing depends on:
- Usage volumes (size/frequency of datasets).
- Deployment model (Tonic Cloud vs. self-hosted).
- Number of workspaces/teams and required integrations.

Two common patterns:

Team/Project Plan: Best for product and QA teams needing to generate realistic relational datasets for a handful of services or demo environments.
Enterprise Plan: Best for organizations standardizing synthetic data across engineering, QA, and AI initiatives, often combining Fabricate with Structural and Textual, SSO/SAML, and governance controls.

To get precise pricing and plan details, the fastest path is to book a demo or contact Tonic sales; they’ll map Fabricate usage to your environments and workloads.

Frequently Asked Questions

How is Tonic Fabricate different from writing my own SQL scripts or Faker-based generators?

Short Answer: Fabricate replaces brittle, one-off generators with a Data Agent that understands schemas, relationships, and realistic patterns—so you get relational data that actually behaves like production without maintaining custom scripts.

Details: DIY Faker scripts can generate columns in isolation, but they rarely maintain cross-table relationships, realistic distributions, or edge cases. They also tend to break as schemas evolve, and script owners become single points of failure. Fabricate uses foundation models with domain knowledge to generate coherent schemas and data, enforces foreign keys across the full database, and lets you iterate with natural language prompts instead of code changes. That means when you need “100K customers with 10% premium, realistic churn patterns, and related orders,” you describe the outcome—not how to code it.

Can I use a mix of Tonic Structural and Tonic Fabricate for my relational datasets?

Short Answer: Yes. Use Structural to transform real production databases into de-identified, referentially intact test data, and Fabricate to generate entirely synthetic datasets or fill gaps where you don’t have real data.

Details: Many teams pair the two:

Tonic Structural: Scans production databases, detects sensitive columns, applies privacy-preserving transforms, and subsets data with referential integrity. It’s ideal when you want production-shaped test data that closely matches real schemas and distributions, but with sensitive values removed or synthesized.
Tonic Fabricate: Jumps in when you don’t have a production dataset yet, can’t safely access it, or need a domain-specific dataset that doesn’t exist in your systems. You use Fabricate to generate schematized, relational synthetic data by describing the schema and patterns you need.

Together, they cover both sides of the problem: safely reusing production structures where you can, and generating new synthetic relational datasets where you can’t.

Summary

Signing up for Tonic Fabricate and generating a relational dataset from a schema is deliberately straightforward: create a Tonic account, open a Fabricate project, define or import your schema via the Data Agent, configure your volumes and relationships, and export synthetic data to your target environment. Instead of copying production databases into dev or spending weeks maintaining custom generators, you get high-fidelity, relational synthetic datasets on demand—letting your teams ship faster without creating new privacy risks.

Next Step

Get Started