Synthetic Data for Development: Test Realistic Data Without Privacy Risks

Developers need realistic data to build and test applications. Historically, teams copied production databases to their development environments — complete with real customer names, emails, and payment information. This is a compliance and security nightmare.

Synthetic data solves this by generating realistic data that never belonged to a real person.

Why Production Data Is Risky

1. GDPR/CCPA violations: Using real customer data in development violates privacy regulations
2. Data breaches: Development environments have weaker security than production
3. Compliance audits: Auditors will flag production data in non-production environments
4. Legal exposure: If a developer's laptop with production data is lost, you have a reportable breach
5. Data drift: Production copies become stale, creating inconsistent test environments

Synthetic Data Tools

General Purpose

AI-Enhanced Generation

Modern tools use AI to generate data that preserves statistical properties of your production data without copying any real records:

// Using Faker.js for basic synthetic data
import { faker } from '@faker-js/faker';

function generateCustomer() {
  return {
    id: faker.string.uuid(),
    name: faker.person.fullName(),
    email: faker.internet.email(),
    phone: faker.phone.number(),
    address: {
      street: faker.location.streetAddress(),
      city: faker.location.city(),
      state: faker.location.state(),
      zip: faker.location.zipCode(),
    },
    plan: faker.helpers.arrayElement(['free', 'pro', 'enterprise']),
    createdAt: faker.date.past({ years: 2 }),
    monthlySpend: faker.number.float({ min: 0, max: 5000, fractionDigits: 2 }),
  };
}

// Generate 1000 customers
const customers = Array.from({ length: 1000 }, generateCustomer);

Database-Aware Tools (Snaplet)

Snaplet understands your Postgres schema, respects foreign keys, and generates consistent relational data:

// snaplet.config.ts
import { defineConfig } from '@snaplet/seed';

export default defineConfig({
  select: {
    public: {
      users: true,
      orders: true,
      products: true,
    },
  },
  transform: {
    public: {
      users: ({ row }) => ({
        email: faker.internet.email(),
        name: faker.person.fullName(),
        phone: faker.phone.number(),
      }),
    },
  },
});

Structured Approaches

Seed Scripts

Keep seed scripts in your repository. Every developer runs them to get a consistent baseline:

pnpm db:seed  # Generate synthetic data for development

Factory Pattern

Define factories for each data model and compose them:

const userFactory = createFactory<User>({
  name: () => faker.person.fullName(),
  email: () => faker.internet.email(),
  role: () => 'user',
});

const orderFactory = createFactory<Order>({
  userId: () => userFactory.create().id,
  total: () => faker.number.float({ min: 10, max: 500 }),
  status: () => faker.helpers.arrayElement(['pending', 'completed', 'cancelled']),
});

// Create test data with overrides
const adminUser = userFactory.create({ role: 'admin' });
const largeOrder = orderFactory.create({ total: 9999.99 });

Snapshot-Based

Take a production database snapshot, transform all PII (personally identifiable information), and use it as your development baseline. This preserves real data patterns while removing real identities.

Edge Cases to Test

Good synthetic data includes edge cases your production data might not cover:

• Unicode names and addresses
• Very long strings that test field limits
• Empty/null values
• Future and past dates
• Negative numbers where unexpected
• Special characters in email addresses
• International phone number formats

ROI

Our Practice

We use Faker.js and custom seed scripts in every project. No production data ever touches a development environment. Our seed scripts generate comprehensive test data that covers happy paths, edge cases, and error scenarios, giving developers and QA confident test coverage from day one.