DEV Community: Dhanush Gowda

I Built a Relational SQL Data Generator to Stop Writing Manual Test Seeds

Dhanush Gowda — Mon, 14 Sep 2026 09:36:26 +0000

Every time I start setting up local staging environments or testing SQL queries, I run into the same problem: generating dummy data for complex database schemas is annoying.

Existing tools usually generate flat CSV files. That works for a single table, but as soon as you have foreign keys (like users $\rightarrow$ orders $\rightarrow$ payments), manual seed scripts quickly turn into a headache.

To fix this for my own workflow, I built SeedSQL—a web tool that generates realistic, referentially valid SQL mock data.

The Problem with Mock Data
When testing multi-table schemas, flat random generators usually break your database constraints:

Foreign Key Mismatches: Child tables reference IDs that don't exist in parent tables.

Format Errors: Generated strings don't match strict SQL data types like UUID, TIMESTAMP, or VARCHAR.

Manual Setup: Writing 500 lines of custom INSERT INTO statements just to test a single query wastes hours.

How SeedSQL Works
You define your database schema (or select tables like users, products, orders), and SeedSQL generates relational datasets while maintaining strict key integrity:

You define your database schema (or select tables like users, products, orders), and SeedSQL generates relational datasets while maintaining strict key integrity:

Dependency Mapping: It automatically detects parent-child table relationships so parent rows exist before child rows link to them.

Key Preservation: Foreign keys in child tables correctly pull from the generated primary keys of parent tables.

Instant Export: You can export the generated data directly as clean .sql insert scripts or CSVs ready to load straight into PostgreSQL or MySQL.

Key Features
Multi-Table Relational Data: Keep foreign keys valid across complex schema hierarchies.

Localization Support: Generate country-specific details (names, phone formats, addresses).

Instant SQL Export: Get raw INSERT scripts formatted directly for your target SQL dialect.

Free Tier: Generate up to 1,000 rows instantly for quick schema tests.

Try It Out
If you're tired of manually writing seed files or cleaning up broken foreign key constraints, check out https://seed-sql.ai.studio/

I'd love to hear your feedback—what features or database dialects would make your testing workflow easier? Let me know in the comments!

I built a tool to generate relational SQL seed data with preserved foreign keys.

Dhanush Gowda — Tue, 01 Sep 2026 18:12:38 +0000

Hand-writing mock SQL data for local testing is slow, and using LLMs breaks down when you need thousands of rows with strict relational constraints.

To solve this, I built SeedSQL—a free tool to generate referentially accurate synthetic data in seconds.

Why I Built
ItMocking local database schemas usually causes three main headaches:
Broken Foreign Keys: Standard generators treat tables independently, creating orphaned relationships (Users $\rightarrow$ Orders).

AI Limits: Prompting LLMs for large datasets gets slow, hits token caps, and yields non-deterministic outputs.

Formatting Hassles: Cleaning up raw text or CSVs into usable SQL takes extra time.

Key Features
Preserves Foreign Keys: Automatically maps parent-child primary keys across connected tables.

Flexible Data Types: Supports UUIDs, timestamps, custom regex patterns, localized names, and ranges.

Instant Export: Outputs ready-to-run INSERT statements (PostgreSQL, MySQL, SQLite) or structured JSON.

Deterministic Output: Re-run identical seeds across team dev setups and test pipelines.

I’d love to get feedback from developers using it:

Try the tool: https://seed-sql.ai.studio/

Feedback: What database engines or features would make your seeding workflow easier? Drop a comment below!

[Boost]

Dhanush Gowda — Fri, 21 Aug 2026 08:24:46 +0000

Dhanush Gowda

Aug 17

Why I Built SeedSQL: Generating Schema-Aware Synthetic Data Without Leaking PII

#database #sql #devtools #webdev

2 min read

Why I Built SeedSQL: Generating Schema-Aware Synthetic Data Without Leaking PII

Dhanush Gowda — Mon, 17 Aug 2026 09:28:15 +0000

Setting up realistic test data for local development and staging environments is a constant headache for developers.

When populating database environments, teams usually face a frustrating tradeoff:

Writing heavy mock scripts using libraries like Faker.js, which takes hours to configure and breaks whenever database schemas change.
Copying production database dumps, which carries massive risks of leaking real PII (Personally Identifiable Information) and violating strict compliance regulations.

To bridge this gap, I built SeedSQL—an AI-powered data engine designed to make seeding relational databases fast, realistic, and completely privacy-safe.

The Challenge with Generic Data Generators

Most generic mock generators treat database tables as isolated islands. Generating 1,000 fake user names or random emails is easy, but real production databases depend on tight relational rules:

• Foreign Key Dependencies: Inserting an orders row with an invalid user_id breaks constraint integrity immediately.

• Contextual Data Types: Payment amounts need realistic decimal ranges, while order dates must follow logical user signup timelines.

• Schema Drift: Modifying your schema requires updating mock scripts across your entire test suite.

SeedSQL approaches data generation by analyzing your entire database schema upfront before creating a single row.

Key Features:

• Instant Schema Parsing: Paste your raw SQL DDL (CREATE TABLE statements) or upload schema files. SeedSQL automatically maps tables, datatypes, and foreign key relations.

• Foreign Key Integrity: Primary and foreign keys line up across dependent tables (users, orders, payments), preventing FOREIGN KEY constraint errors during INSERT.

• Zero Production Data Leakage: Keeps staging and local development environments completely PII-free while maintaining production-like data distribution.

• Clean SQL Exports: Generates standard, ready-to-run .sql insert scripts compatible with PostgreSQL, MySQL, and SQLite.

Getting Started in 3 Steps

Import Your Schema: Paste your DDL SQL statements into the editor.
Set Row Counts: Specify how many mock records you need per table.
Export & Run: Download your ready-to-execute .sql script and seed your local or staging database immediately.

Try SeedSQL Today

Whether you are running local integration tests, setting up staging environments, or preparing realistic database mocks for demos, SeedSQL cuts out manual data generation scripts entirely.

Check out SeedSQL at seedsql.ai.studio and let me know your thoughts, questions, or feedback in the comments!