weavori vs drizzle-seed
Weavori vs drizzle-seed
Drizzle's official seeding package — deterministic, in code
drizzle-seed is Drizzle's official seeding package: it reads your Drizzle TypeScript schema, generates deterministic fake data through a seedable pseudo-random generator, and lets you shape behaviour per table with a refine callback. It is free, MIT, and for a Drizzle-native project a genuinely fast start — a few lines to a populated database, reproducible across runs. What it cannot do is read the database. It works from the TypeScript schema definition, so realism comes from generator functions and refinements you maintain by hand. Weavori reads the live PostgreSQL schema, samples pg_stats so distributions match production, and needs no seeding code at all.
Pricing verified September 2026 · Open-source library (TypeScript) · drizzle-seed website ↗
At a glance
| Dimension | Weavori | drizzle-seed |
|---|---|---|
| Category | Schema-driven CLI | In-code seeding library |
| Source of truth | The live database | Your Drizzle TypeScript schema |
| Determinism | Yes (seed semantics) | Yes (seedable pRNG) |
| Distributions | Sampled from pg_stats | Generator defaults plus your refinements |
| FK integrity | By construction, parent-first | By construction, from declared relations |
| Cross-column coherence | Temporal ordering, conditional nullability, CHECK constraints | Relation references and weighted counts |
| Setup | One command, no code | Install, then write a seed script |
| Drift risk | None — the database is re-read every run | Refinements can drift from the schema |
| Scale | Streaming, constant memory | Runs inside your Node process |
| Cost | Free 2K rows/mo; Pro $15/mo | Free (MIT) |
See the plan before a single row is written
Point Weavori at any PostgreSQL database — the preview shows what it will generate, table by table.
How they compare
A closer look at the dimensions that actually change the decision, and where each tool wins.
Where the data comes from
weavori
Weavori connects to PostgreSQL and reads the schema that actually exists — foreign keys, composite keys, CHECK constraints, enums, triggers, defaults — plus pg_stats. The database is the source of truth on every run.
drizzle-seed
drizzle-seed reads your Drizzle schema definition: tables, columns, and relations declared in TypeScript. That is what it generates against. If the live database has drifted from the schema file, or holds statistics the schema file never described, drizzle-seed cannot see either.
Bottom line: Inside a Drizzle project the schema file is the natural source of truth, and drizzle-seed honours it faithfully. When the question is what production actually looks like, only reading the database answers it.
Realism and who does the work
weavori
Realism is measured, not authored: value frequencies come from pg_stats, so a status column that is 70% active stays 70% active. Cross-column coherence — temporal ordering, conditional nullability, CHECK constraints — is enforced out of the box, alongside roughly 230 semantic column rules for common naming conventions.
drizzle-seed
Realism is authored. drizzle-seed ships generator functions and a refine callback that receives them, so you describe the shape of each table, including weighted randomness for how many referenced rows to create. Defaults are plausible; anything closer to your production distribution is code you write and keep.
Bottom line: For a prototype or a reproducible fixture, authored realism is enough and costs nothing. For a dataset that has to behave like production — where query plans depend on skew — measured realism is the difference.
Determinism and repeatability
weavori
Weavori supports deterministic generation through its seed semantics, so a run can be reproduced exactly while the distributions are still shaped by the live database.
drizzle-seed
Determinism is drizzle-seed's core design goal. A seedable pseudo-random generator makes runs reproducible across machines, which is exactly what you want for fixtures and snapshot tests.
Bottom line: Closer than it looks: both are deterministic. Choose drizzle-seed when in-process reproducibility with no database is the requirement; choose Weavori when you want a reproducible run whose data still matches production distributions.
Maintenance cost
weavori
There is no seeding code to maintain. Add a column, rename a field, drop a table — the next run adapts, because the schema is read rather than described. Nothing in your codebase duplicates the database's structure.
drizzle-seed
Refinements are code, and code drifts. Add a column and your refinements may silently stop covering it; rename a table and they break. It is the same class of maintenance as any hand-written seed script, expressed in Drizzle's API.
Bottom line: If your data needs are static and small, refinement code is a one-time cost. If your schema is moving, a tool with nothing to maintain is cheaper across a year.
Which one fits your team?
choose weavori when
- Datasets that must behave like production, where skew and value frequency matter
- Teams that don't want to write or maintain seeding and refinement code
- Seeding large schemas or large row counts from a CLI
- CI pipelines that need a fresh, schema-accurate database per run
- Any PostgreSQL project, Drizzle or not
choose drizzle-seed when
- Drizzle-native projects that want a populated database in a few lines
- Reproducible in-code fixtures for unit and snapshot tests
- Teams that want zero new dependencies and zero cost
- Full programmatic control over every generated value
Install Weavori and run it on your database
Free tier with unlimited runs, or the full-Pro trial for 14 days — no credit card either way.
Frequently asked questions
The questions we hear most from teams evaluating Weavori against drizzle-seed.
Try Weavori against your own schema
Connect any PostgreSQL database and see the plan before a single row is written.
No credit card required. 14-day full-Pro trial, then free tier or subscribe.
Also compare: Tonic.ai · Mockaroo · Faker · How realistic test data is made