Large Seeding: Seed Millions of Records

Control exactly how much data Seedfast generates — from dozens to millions of rows, described in plain English.

What Changed

You used to run seedfast seed and hope for the best. The tool decided how many records to create — usually 5 to 30 rows per table. Enough to prove the schema works, but not enough for anything real. You couldn't ask for more, and you couldn't control proportions.

That's no longer the case. With the latest large seeding update, you describe what you need in natural language, and Seedfast builds a plan that matches. Fifty users for local development? A million orders for load testing? You just say so.

seedfast seed --scope "seed 1 million orders with line items"

Before anything is written, you see the full plan — every table, every row count. You approve, refine, or cancel. No surprises, no wasted time.

How It Works

1. You describe the scope — what tables, how many records, any constraints

2. Seedfast builds a plan — analyzes your schema, resolves dependencies, determines row counts per table

3. You see a preview — table names, record counts, and descriptions

4. You approve or refine — if something's off, you say what to change right in the terminal

5. Done — results with per-table stats

If your scope asks for more tables than your plan allows, Seedfast doesn't bail. It asks you to narrow down — right there, no restart needed. You refine, Seedfast replans, and you move on.

If there are dependency issues — say, a table needs data from another table you didn't include — Seedfast warns you before seeding starts. Not halfway through, when you've already been waiting for minutes.

Use Cases

Load Testing

Thirty rows won't surface the slow query that only appears at 100K. You need a database that behaves like production under pressure.

seedfast seed --scope "seed 1 million orders with line items"

Seeding Plan:
  public.orders         — 1,000,000 records
  public.order_items    — 3,500,000 records
  public.customers      — 200,000 records

Total: 4,700,000 records across 3 tables

Approve? (Y/n)

You said “orders with line items” — Seedfast figured out that you also need customers to place those orders, and worked backward through the dependency chain.

Development

You want a populated database for local development. Enough data to test pagination, search, and filters — but not so much that your laptop struggles.

seedfast seed --scope "seed 50 users with orders and invoices"

Seeding Plan:
  public.users          — 50 records
  public.orders         — 250 records
  public.invoices       — 250 records
  public.order_items    — 800 records

Total: 1,350 records across 4 tables

Approve? (Y/n): I need more orders, at least 500

The plan looked almost right, but you wanted more orders. No problem — just type what you'd change instead of pressing Y. Seedfast replans:

Updated Seeding Plan:
  public.users          — 50 records
  public.orders         — 500 records
  public.invoices       — 250 records
  public.order_items    — 1,600 records

Total: 2,400 records across 4 tables

Approve? (Y/n)

You can refine as many times as needed. The session stays alive — no restarting, no re-authenticating.

Demo Environments

You're preparing a demo for a client. The database needs to look populated and real — not three rows that scream “test data.”

seedfast seed --scope "seed 500 customers across 3 regions with support tickets"

But Seedfast spots a problem before it starts:

Heads up — 1 issue to resolve before seeding

  public.support_tickets depends on public.agents which has 0 rows.
  Add public.agents to scope, or remove public.support_tickets from scope.

How would you like to proceed

You could add agents to scope, drop support tickets, or describe the fix in your own words. Either way, you find out now — not after 5 minutes of seeding when a foreign key violation kills the run.

Your answer: add agents too, around 20

Updated Seeding Plan:
  public.regions         — 3 records
  public.agents          — 20 records
  public.customers       — 500 records
  public.support_tickets — 1,200 records
  public.ticket_comments — 3,500 records

Total: 5,223 records across 5 tables

Approve? (Y/n)

QA and Regression Testing

Your QA team needs enough data to exercise every code path. Edge cases only appear when there's volume — and when the scope covers the whole domain.

seedfast seed --scope "seed all e-commerce tables, 10K products and 50K orders"

Scope Exceeds Plan Limit

Your scope resolves to 35 tables, but your plan allows 20 per seeding.

You can:
  Refine your scope to reduce the number of tables
  Upgrade your plan at https://seedfa.st/pricing

Describe the updated scope:
  seed only products, orders, order_items, categories, and customers — 10K products, 50K orders

Seedfast replans with the narrower scope:

Seeding Plan:
  public.categories     — 25 records
  public.customers      — 8,000 records
  public.products       — 10,000 records
  public.orders         — 50,000 records
  public.order_items    — 150,000 records

Total: 218,025 records across 5 tables

Approve? (Y/n)

No restart, no guessing which tables to cut. The whole conversation happens in one terminal session.

Writing Effective Scopes

The scope is plain text. You describe what you want, Seedfast interprets it. The better your description, the closer the plan matches your intent.

What Works Well

Specific table names and counts:

seed 1000 users and 5000 orders

Proportions between tables:

seed 100 customers, each with 10 orders

Schema-level targets:

seed all tables in the billing schema, 500 records each

Volume with relationships:

seed 1 million transactions with associated accounts and categories

What Doesn't Work Well

Too vague:

seed some data

Seedfast will still generate a plan, but without volume guidance it falls back to small defaults.

Contradictory constraints:

seed 10 users with 1 million orders each

This may exceed plan limits or produce impractical results.

Column-level filters:

seed users where country = 'US'

Scope controls what tables and how many rows — not field-level values.

Tips

• Be explicit about numbers. "500 users" beats "a lot of users".

• Name the tables when you can. "seed users, orders, and products" is clearer than "seed the main tables".

• State proportions when they matter. "100 customers, each with 5 orders" gives Seedfast enough context to plan the right ratios.

• Start small, then scale. Try with 100 records first. Once the plan looks right, bump to 100K.

Seeding Plan Preview

Before any data is written, you see exactly what Seedfast intends to do:

Seeding Plan:
  public.users          — 1,000 records
  public.orders         — 5,000 records
  public.order_items    — 15,000 records
  public.products       — 200 records
  public.categories     — 12 records

Total: 21,212 records across 5 tables

Approve? (Y/n)

Each line shows the table name and the number of records.

If the plan doesn't match — don't approve. Just type what you'd change:

Approve? (Y/n): double the products and add shipping_addresses

Seedfast replans and shows an updated preview. Repeat until it's right.

CLI Quick Reference

Interactive Mode

# Seedfast asks what to seed — you describe it live
seedfast seed

With --scope

# Auto-approves if the plan fits your subscription
seedfast seed --scope "seed 1000 users with orders"

When you provide --scope, Seedfast skips the interactive prompt, builds the plan, and starts seeding immediately. This is how you use it in scripts and CI/CD pipelines.

If the scope exceeds limits in --scope mode, Seedfast exits with an error instead of entering interactive replan — because there's nobody at the terminal to refine.

Output Modes

# Default: rich terminal UI with progress bars
seedfast seed --scope "..."

# Timestamped logs for CI/CD
seedfast seed --scope "..." --output plain

# Machine-readable JSON
seedfast seed --scope "..." --output json

Ready to seed at scale?

Get Started | Documentation | Pricing

Large Seeding is available in Seedfast CLI v2.0+ on all platforms. Install or update