Your Fast Prisma Setup: 5 Essential Steps for 2025

Step 3: Seeding Your Database Like a Pro

Starting with an empty database during development is a pain. You need sample data to test features, build UIs, and verify logic. Prisma has a built-in seeding feature to solve this exact problem.

First, add a `seed` script to your `package.json`:

// package.json
"prisma": {
  "seed": "ts-node --compiler-options {\"module\":\"CommonJS\"} prisma/seed.ts"
}

Next, create the seed file at `prisma/seed.ts`. Here, you can write a script to populate your database with initial data.

// prisma/seed.ts
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function main() {
  console.log('Start seeding ...');

  // Create two users
  const user1 = await prisma.user.create({
    data: {
      email: 'john.doe@example.com',
      name: 'John Doe',
      posts: {
        create: [
          {
            title: 'Hello World',
            content: 'This is my first post!',
            published: true,
          },
          {
            title: 'Prisma is Awesome',
            content: 'Just learning about seeding.',
          },
        ],
      },
    },
  });

  const user2 = await prisma.user.create({
    data: {
      email: 'jane.smith@example.com',
      name: 'Jane Smith',
    },
  });

  console.log(`Created users: ${user1.name}, ${user2.name}`);
  console.log('Seeding finished.');
}

main()
  .catch((e) => {
    console.error(e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

Now, anytime you want to seed your database, simply run:

npx prisma db seed

This is incredibly useful for creating a consistent development environment for you and your team.

Step 4: Mastering Migrations with `prisma migrate`

As your application evolves, so will your database schema. Managing these changes is critical. While `prisma db push` is fine for rapid prototyping, for any serious project (including robust development workflows), you should use `prisma migrate`.

`prisma migrate` creates discrete, timestamped SQL migration files that act as a historical record of your schema changes. This is essential for collaborative work and deploying to production.

The workflow is simple:

1. Modify your schema: Make a change to a model in `schema.prisma`. For example, let's add a `viewCount` to our `Post` model.
   model Post { ... viewCount Int @default(0) }
2. Run the migrate command: Use the `migrate dev` command to generate and apply the migration in your development environment.
   

   npx prisma migrate dev --name add_post_view_count

3. Review the result: Prisma will create a new directory in `prisma/migrations` containing a `migration.sql` file. This file contains the exact SQL needed to apply the change. It then applies this migration to your dev database.

When it's time to deploy, you can confidently run `npx prisma migrate deploy` in your production environment to apply all pending migrations. This workflow is robust, repeatable, and prevents database drift.

Step 5: Optimizing Queries to Avoid Over-Fetching

A fast setup isn't just about initialization; it's about performance in production. One of the most common performance pitfalls is over-fetching—querying more data than you actually need. Prisma gives you powerful tools to surgically select only the data required.

Imagine you have a page that just lists the titles of all published posts. A naive query might look like this:

const posts = await prisma.post.findMany({ where: { published: true } });

This works, but it pulls all fields for each post (`id`, `title`, `content`, `authorId`, etc.) from the database, which can be wasteful, especially if the `content` field contains a lot of text.

A much better approach is to use the `select` option:

const postTitles = await prisma.post.findMany({
  where: { published: true },
  select: {
    id: true, // It's good practice to always get the id
    title: true,
  },
});

This query tells the database to only return the `id` and `title` columns, dramatically reducing the data payload and improving performance.

Query Payload Comparison

Here’s a simple comparison of the data returned by the two approaches:

[
  {
    "id": 1,
    "title": "Hello World",
    "content": "...",
    "published": true,
    "authorId": 1,
    "createdAt": "..."
  }
]

[
  {
    "id": 1,
    "title": "Hello World"
  }
]

Similarly, use `include` to fetch related data when you need it, but be mindful not to nest it too deeply without cause. Thoughtful use of `select` and `include` is the key to a high-performance, Prisma-backed API.

Conclusion: Your Foundation for a Modern Backend

And there you have it! By following these five steps—Initialization, Client Generation, Seeding, Migrations, and Query Optimization—you've built a Prisma setup that is not only functional but also robust, efficient, and a joy to work with. You've established a single source of truth with your schema, enabled a type-safe development experience, created a repeatable environment with seeding, ensured safe schema evolution with migrations, and learned how to write performant queries.

This solid foundation frees you from the tedious parts of database management, allowing you to focus on what truly matters: building incredible features for your users. Now go build something amazing!