Mern Stack
Mongodb
React
Nodejs
Expressjs

Database Seeding

Nisarg Patel

9 min readOct 9, 2026

Database Seeding in MERN Stack: A Complete Guide with Practical Implementation

Author: Nisarg Patel

Technologies: MongoDB, Express.js, React.js, Node.js, Mongoose

1. Introduction

In modern full-stack web development, databases are essential for storing, managing, and retrieving information. When developers create a new application, the database is often empty and needs initial data for testing and configuration.

Database Seeding is the process of inserting predefined or initial data into a database using scripts or application logic.

In the MERN stack, database seeding can be implemented using Node.js and Mongoose to insert predefined documents into MongoDB.

For example, a Student Management System may require sample student records to demonstrate its features. Instead of inserting each record manually, developers can execute a seed script to populate the database automatically.

This article explains database seeding, its working process, types, implementation, benefits, limitations, and real-world applications using the MERN stack.

2. What Is Database Seeding?

Database seeding is a technique for populating a database with initial or predefined data.

The data inserted through this process is called seed data.

Examples include:

Sample student records
Default product categories
User roles and permissions
Application settings
Demo products
Test records

For example, a Student Management System may require student names, email addresses, courses, and semesters. A seed script can insert these records automatically instead of requiring developers to add them manually.

3. Why Is Database Seeding Important?

1. Saves Time: Developers can insert multiple records by executing a single script.

2. Simplifies Testing: Sample records help test API endpoints, searching, filtering, and CRUD operations.

3. Maintains Consistency: The same predefined dataset can be used across development environments.

4. Supports Application Setup: Required default records can be created when an application is initialized.

5. Improves Productivity: Developers spend less time entering test data manually.

6. Simplifies Demonstrations: Sample data makes it easier to demonstrate application functionality.

4. Types of Database Seeding

4.1 Static Data Seeding

Static seeding inserts predefined data that rarely changes, such as product categories or user roles.

4.2 Dynamic Data Seeding

Dynamic seeding generates data programmatically, for example, creating hundreds of sample users using a data-generation library.

4.3 Conditional Seeding

Conditional seeding checks whether a record already exists before inserting it. This helps avoid duplicate records.

4.4 Development and Testing Seeding

This approach inserts sample records specifically for development, demonstrations, or automated testing.

5. Database Seeding in MERN Stack

MERN is a JavaScript-based technology stack used to develop full-stack web applications.

MongoDB: A NoSQL database that stores information as BSON documents.
Express.js: A backend framework for creating REST APIs.
React.js: A JavaScript library for building interactive user interfaces.
Node.js: A JavaScript runtime used to execute backend code.
Mongoose: An Object Data Modeling library that helps Node.js applications interact with MongoDB.

In this project, a Node.js seed script uses Mongoose to insert student records into MongoDB. Express.js provides an API to retrieve those records, and React.js displays them in the browser.

6. Architecture and Working Flow

Database Seeding Flow

Developer
   |
   v
Run Seed Script
   |
   v
Node.js + Mongoose
   |
   v
Connect to MongoDB
   |
   v
Check Existing Records
   |
   v
Insert Missing Records
   |
   v
MongoDB Database

Application Data Flow

React Frontend
      |
      | HTTP GET Request
      v
Express.js REST API
      |
      v
Mongoose Model
      |
      v
MongoDB Database
      |
      v
JSON Response
      |
      v
React Student Table

The seed script and application server perform different tasks. The seed script initializes data, while the Express API retrieves the stored information for the frontend.

7. Practical Implementation

We will create a Student Management System using MongoDB, Express.js, React.js, Node.js, and Mongoose.

Project Requirements

Node.js and npm
MongoDB Community Server
Visual Studio Code
MongoDB Compass (optional)

Step 1: Create the Project

Open the terminal and execute:

mkdir database-seeding-mern
cd database-seeding-mern
mkdir backend
cd backend
npm init -y

Step 2: Install Dependencies

npm install express mongoose cors dotenv

These packages provide the backend framework, database connectivity, cross-origin request handling, and environment configuration.

Step 3: Configure the Database

Create a .env file inside the backend directory:

MONGO_URI=mongodb://127.0.0.1:27017/seeding_demo
PORT=5000

Here, seeding_demo is the MongoDB database name.

MongoDB creates the database when the application first writes data to it, provided the connection and database permissions are valid.

Keep sensitive credentials out of public repositories.

Step 4: Create the Student Model

Create a folder named models, then create Student.js inside it.

const mongoose = require("mongoose");

const studentSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    trim: true
  },
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true,
    trim: true
  },
  course: {
    type: String,
    required: true
  },
  semester: {
    type: Number,
    required: true
  }
});

module.exports = mongoose.model(
  "Student",
  studentSchema
);

Explanation:

The schema defines the structure of each student document. The required option validates mandatory fields, while unique requests a unique index for the email field.

Mongoose models allow us to create, retrieve, and manage student documents in MongoDB.

Step 5: Create the Seed Script

Create a folder named seed and add a file called seedStudents.js.

require("dotenv").config();

const mongoose = require("mongoose");
const Student = require("../models/Student");

const students = [
  {
    name: "Rahul Patel",
    email: "rahul@example.com",
    course: "B.Sc IT",
    semester: 6
  },
  {
    name: "Priya Shah",
    email: "priya@example.com",
    course: "BCA",
    semester: 4
  },
  {
    name: "Amit Mehta",
    email: "amit@example.com",
    course: "B.Sc CS",
    semester: 6
  },
  {
    name: "Neha Desai",
    email: "neha@example.com",
    course: "B.Sc IT",
    semester: 2
  },
  {
    name: "Karan Joshi",
    email: "karan@example.com",
    course: "BCA",
    semester: 6
  }
];

async function seedDatabase() {
  try {
    await mongoose.connect(process.env.MONGO_URI);

    console.log("MongoDB Connected");

    await Student.init();

    const operations = students.map((student) => ({
      updateOne: {
        filter: { email: student.email },
        update: { $setOnInsert: student },
        upsert: true
      }
    }));

    const result = await Student.bulkWrite(operations);

    console.log(
      "New students inserted:",
      result.upsertedCount
    );

    console.log("Database Seeding Completed");
  } catch (error) {
    console.error("Seeding Error:", error);
    process.exitCode = 1;
  } finally {
    await mongoose.disconnect();
  }
}

seedDatabase();

Explanation:

mongoose.connect() connects the script to MongoDB.
The students array contains predefined student records.
Student.init() waits for model initialization, including index creation when necessary.
bulkWrite() executes multiple database operations.
upsert: true inserts a record when its email does not already exist.
$setOnInsert preserves existing records rather than overwriting them.
mongoose.disconnect() closes the database connection when the script finishes.

This approach makes the seed script safe to rerun for the predefined email addresses, assuming the unique index is successfully established.

Step 6: Configure the Seed Command

Open backend/package.json and add these scripts inside its existing scripts object:

"scripts": {
  "start": "node server.js",
  "seed": "node seed/seedStudents.js"
}

Keep the existing dependency entries in package.json.

Execute:

npm run seed

On an empty database, the expected output is similar to:

MongoDB Connected
New students inserted: 5
Database Seeding Completed

When the script runs again, the expected insertion count is zero if all five records already exist.

This demonstrates conditional seeding and duplicate prevention.

Step 7: Verify Records in MongoDB

Open MongoDB Compass and connect to:

mongodb://127.0.0.1:27017

Open the database named seeding_demo, followed by the students collection.

Get Nisarg Patel’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

A student document will look similar to:

{
  "_id": "MongoDB-generated ObjectId",
  "name": "Rahul Patel",
  "email": "rahul@example.com",
  "course": "B.Sc IT",
  "semester": 6
}

MongoDB automatically generates an ObjectId for each document.

Step 8: Create the Express API

Create server.js inside the backend folder.

require("dotenv").config();

const express = require("express");
const mongoose = require("mongoose");
const cors = require("cors");

const Student = require("./models/Student");

const app = express();

app.use(cors({
  origin: "http://localhost:5173"
}));

app.use(express.json());

app.get("/", (req, res) => {
  res.send("Database Seeding MERN API");
});

app.get("/api/students", async (req, res) => {
  try {
    const students = await Student.find()
      .sort({ name: 1 });

    res.json(students);
  } catch (error) {
    res.status(500).json({
      message: "Failed to fetch students"
    });
  }
});

async function startServer() {
  try {
    await mongoose.connect(process.env.MONGO_URI);

    console.log("MongoDB Connected");

    const PORT = process.env.PORT || 5000;

    app.listen(PORT, () => {
      console.log(`Server running on port ${PORT}`);
    });
  } catch (error) {
    console.error("Database Error:", error);
    process.exit(1);
  }
}

startServer();

The /api/students endpoint retrieves the student documents from MongoDB and returns them as JSON. The results are sorted alphabetically by name.

Start the backend:

npm start

Open:

http://localhost:5000/api/students

The response should contain the five seeded student records.

Step 9: Create the React Frontend

Open a second terminal in the root project directory and execute:

npm create vite@latest frontend -- --template react
cd frontend
npm install

Replace the contents of frontend/src/App.jsx with:

import { useEffect, useState } from "react";
import "./App.css";

function App() {
  const [students, setStudents] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState("");

  useEffect(() => {
    async function fetchStudents() {
      try {
        const response = await fetch(
          "http://localhost:5000/api/students"
        );

        if (!response.ok) {
          throw new Error("Failed to fetch students");
        }

        const data = await response.json();
        setStudents(data);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    }

    fetchStudents();
  }, []);

  return (
    <div className="container">
      <h1>Student Management System</h1>
      <p>Database Seeding Using MERN Stack</p>

      {loading && <p>Loading students...</p>}
      {error && <p role="alert">{error}</p>}

      {!loading && !error && (
        <table>
          <thead>
            <tr>
              <th>No.</th>
              <th>Name</th>
              <th>Email</th>
              <th>Course</th>
              <th>Semester</th>
            </tr>
          </thead>

          <tbody>
            {students.map((student, index) => (
              <tr key={student._id}>
                <td>{index + 1}</td>
                <td>{student.name}</td>
                <td>{student.email}</td>
                <td>{student.course}</td>
                <td>{student.semester}</td>
              </tr>
            ))}
          </tbody>
        </table>
      )}
    </div>
  );
}

export default App;

Step 10: Style the React Application

Replace the contents of frontend/src/App.css with:

body {
  margin: 0;
  font-family: Arial, sans-serif;
  background: #f4f6f9;
}

.container {
  max-width: 1000px;
  margin: 50px auto;
  padding: 25px;
  background: white;
  border-radius: 12px;
  box-shadow: 0 4px 15px rgba(0, 0, 0, 0.08);
}

h1 {
  text-align: center;
  color: #1e293b;
}

p {
  text-align: center;
  color: #64748b;
}

table {
  width: 100%;
  border-collapse: collapse;
  margin-top: 25px;
}

th,
td {
  padding: 14px;
  border: 1px solid #e2e8f0;
  text-align: left;
}

th {
  background: #2563eb;
  color: white;
}

tr:nth-child(even) {
  background: #f8fafc;
}

tr:hover {
  background: #eff6ff;
}

Step 11: Run the Application

Keep MongoDB running and start the backend in the backend terminal:

npm start

Start the frontend in a separate terminal:

npm run dev

Open the local URL displayed by Vite, normally:

http://localhost:5173

The frontend should display the student records retrieved from MongoDB through the Express API.

If Vite uses a different port, update the backend’s CORS origin accordingly.

8. Expected Output

The Student Management System should display a table similar to the following:

No.NameEmailCourseSemester1Amit Mehtaamit@example.comB.Sc CS62Karan Joshikaran@example.comBCA63Neha Desaineha@example.comB.Sc IT24Priya Shahpriya@example.comBCA45Rahul Patelrahul@example.comB.Sc IT6

This table represents the expected application output. Actual screenshots should be captured after running the project.

9. Database Seeding vs Manual Insertion

FeatureDatabase SeedingManual InsertionData entryAutomatedManualReusabilitySeed scripts can be reusedSteps may need repeatingSpeedEfficient for repeated setupSlower for many recordsConsistencyPredefined dataDepends on user inputTestingSupports repeatable test environmentsRequires manual preparation

10. Advantages of Database Seeding

Faster Setup: Inserts predefined records without repeated manual work.
Better Testing: Provides sample data for API and frontend testing.
Consistency: Creates a predictable starting dataset.
Automation: Can be incorporated into development workflows.
Reusability: Seed scripts can be executed in compatible environments.
Easy Demonstration: Makes it easier to show application features.

11. Limitations of Database Seeding

Duplicate Data: Poorly designed scripts may insert repeated records.
Data Conflicts: Existing information may conflict with seed records.
Security Risks: Sensitive credentials or personal information should not be included in public seed files.
Performance: Very large datasets may require batching and optimization.
Production Risks: Destructive scripts can damage important information.
Maintenance: Seed scripts may need updating when database schemas change.

Developers should test seed scripts carefully and keep development data separate from production data.

12. Best Practices

Use stable identifiers to identify predefined records.
Design scripts that can safely run more than once.
Keep sample data separate from production data.
Store database configuration in environment variables.
Avoid hardcoding sensitive credentials.
Handle connection failures and database errors.
Validate data before inserting it.
Avoid destructive operations unless explicitly required.
Test the script in a development environment before using it elsewhere.

13. Real-World Applications

E-Commerce Applications: Insert default product categories and sample products.

Learning Management Systems: Initialize courses, departments, and user roles.

Content Management Systems: Create default settings and content categories.

Employee Management Systems: Populate departments and job designations.

Testing Environments: Generate sample users and records for repeatable testing.

14. Future Improvements

The project can be extended by adding:

Faker-based sample data generation
Search and filtering
Pagination
Full CRUD operations
Student registration forms
Separate development and testing seed datasets
Automated testing and seed validation
Logging and monitoring for database operations

These improvements can make the project more useful for practical development and testing.

15. Conclusion

Database Seeding is an important technique in full-stack web development. It helps developers initialize databases with predefined information, reduce repetitive work, and maintain consistent development environments.

In this project, we implemented database seeding using Node.js, Mongoose, and MongoDB. We created an Express.js REST API to retrieve student records and a React.js frontend to display them.

We also demonstrated conditional insertion using MongoDB upsert operations to avoid repeatedly inserting the same predefined student records.

Understanding database seeding helps developers simplify application initialization, improve testing workflows, and create more maintainable applications.

Database seeding is not just about inserting sample data; it is about making application setup more consistent, repeatable, and efficient.

References

MongoDB Documentation: https://www.mongodb.com/docs/
Mongoose Documentation: https://mongoosejs.com/docs/
Express.js Documentation: https://expressjs.com/
React Documentation: https://react.dev/
Node.js Documentation: https://nodejs.org/
Vite Documentation: https://vite.dev/

Keywords: Database Seeding, MERN Stack, MongoDB, Mongoose, Express.js, React.js, Node.js, Full Stack Development, Database Initialization, Web Development.

Database Seeding

Database Seeding in MERN Stack: A Complete Guide with Practical Implementation

1. Introduction

2. What Is Database Seeding?

3. Why Is Database Seeding Important?

4. Types of Database Seeding

4.1 Static Data Seeding

4.2 Dynamic Data Seeding

4.3 Conditional Seeding

4.4 Development and Testing Seeding

5. Database Seeding in MERN Stack

6. Architecture and Working Flow

Database Seeding Flow

Application Data Flow

7. Practical Implementation

Project Requirements

Step 1: Create the Project

Step 2: Install Dependencies

Step 3: Configure the Database

Step 4: Create the Student Model

Step 5: Create the Seed Script

Step 6: Configure the Seed Command

Step 7: Verify Records in MongoDB

Get Nisarg Patel’s stories in your inbox

Step 8: Create the Express API

Step 9: Create the React Frontend

Step 10: Style the React Application

Step 11: Run the Application

8. Expected Output

9. Database Seeding vs Manual Insertion

10. Advantages of Database Seeding

11. Limitations of Database Seeding

12. Best Practices

13. Real-World Applications

14. Future Improvements

15. Conclusion

References

Written by Nisarg Patel

No responses yet

Recommended from Medium

I Used npm Wrong for Years

AI knows npm install. What about the rest?

Why Async Code in React Sees Stale State

By Abdlazeez Olasunkanmi

REST API Best Practices: A Complete Guide for Node.js Developers

REST API Best Practices: A Complete Guide for Node.js Developers

Why Your Node Server Drops Requests Every Time You Deploy

Not a Medium member? Read this article here

Real Node.js API Integration Architecture Used in Companies

Most beginners think API development means building a few CRUD endpoints with Express. While that’s a great starting point, real-world API…

TypeScript 7.1 vs 7.0: The Native Compiler Matures

7.0 improved the speed of tsc by 10x! 7.1 is when the tooling catches up.

No responses yet

Recommended from Medium

I Used npm Wrong for Years

AI knows npm install. What about the rest?

Why Async Code in React Sees Stale State

By Abdlazeez Olasunkanmi

REST API Best Practices: A Complete Guide for Node.js Developers

REST API Best Practices: A Complete Guide for Node.js Developers

Why Your Node Server Drops Requests Every Time You Deploy

Not a Medium member? Read this article here

Real Node.js API Integration Architecture Used in Companies

Most beginners think API development means building a few CRUD endpoints with Express. While that’s a great starting point, real-world API…

TypeScript 7.1 vs 7.0: The Native Compiler Matures

7.0 improved the speed of tsc by 10x! 7.1 is when the tooling catches up.