Section Titles

MongoDB CRUD Operations

When beginners first start backend development, one of the first struggles is “storing and managing data.”

CRUD stands for Create, Read, Update, and Delete. These four operations form the backbone of every application. If you are someone who is serious about backend development, understanding MongoDB CRUD operations is non-negotiable

In this blog, we will cover:

What CRUD operations in MongoDB actually mean?
The exact MongoDB commands used in real projects
Practical code examples using MongoDB shell and Node.js
Best practices developers follow in production

What is MongoDB?

MongoDB is a NoSQL database that stores data in a flexible, JSON-like format called documents. Unlike traditional SQL databases that use tables and rows, MongoDB stores data inside collections and documents, which makes it easier to handle real-world application data.

If you are building a student portal, e-commerce app, or job portal, MongoDB allows you to store user data, product details, orders, and more without worrying too much about rigid table structures.

It is widely used with Node.js, Express, and the MERN stack (MongoDB, Express, React, Node.js) because it works naturally with JavaScript. Here’s how a simple document looks in MongoDB:

{

age: 22,

course: "Web Development"

}

Each document is stored inside a collection. A collection is like a folder that stores similar documents. MongoDB is popular because:

It is easy to learn for beginners
It scales well for large applications
It handles unstructured data efficiently
It integrates smoothly with modern web frameworks

1. Create Operations

The Create Operations in MongoDB is used to insert new data into a collection. Whenever a user signs up, submits a form, or adds a product, you are performing a CRUD operation, specifically the “Create” part of CRUD operations in MongoDB.

In MongoDB, we use <insertOne()> and <insertMany()> for creating documents. Here’s a basic example using the MongoDB shell:

db.students.insertOne({

age: 21,

course: "Full Stack Development"

})

This command inserts one document into the <students> collection. However, if you want to insert multiple documents at once:

db.students.insertMany([

{ name: "Anita", age: 22, course: "MERN Stack" },

{ name: "Karan", age: 23, course: "Data Science" }

])

In a real Node.js project, you might use MongoDB like this:

const student = await Student.create({

age: 21,

course: "Full Stack Development"

});

Create operations are the foundation of any CRUD database system. Without creating data, there’s nothing to read, update, or delete.

2. Read Operations

The Read operation in MongoDB is used to fetch data from a collection. Whenever you display users, products, blog posts, or student records on a website, you are performing the “Read” part of CRUD operations in MongoDB.

In MongoDB, the most commonly used command for reading data is <find()>. To fetch all documents from a collection:

db.students.find()

If you want to fetch specific data, you can add a condition:

db.students.find({ name: "Rohit" })

This will return only the documents where the name is Rohit. To fetch just one document, use:

db.students.findOne({ name: "Rohit" })

In a real Node.js application, it looks like this:

const students = await Student.find();

Or with a condition:

const student = await Student.findOne({ name: "Rohit" });

One important thing beginners often miss in MongoDB CRUD operations is filtering properly. If you don’t use conditions correctly, your app may return too much data, which affects performance.

Read operations are critical in every CRUD database because data is useful only when you can retrieve it efficiently. Mastering <find()> and filtering will make your MongoDB CRUD skills much stronger.

3. Update Operations

The Update operation in MongoDB is used to modify existing data inside a collection. In real applications, this happens when a user updates their profile, changes a password, edits a product price, or updates course details. This is the third step in CRUD operations in MongoDB.

MongoDB provides <updateOne()>, <updateMany()>, and replaceOne() for update-related MongoDB commands.

To update a single document:

db.students.updateOne(

{ name: "Rohit" },

{ $set: { age: 22 } }

)

The first object is the filter (which document to update)
<$set> modifies only the specified field

To update multiple documents:

db.students.updateMany(

{ course: "MERN Stack" },

{ $set: { course: "Full Stack Development" } }

)

A common beginner mistake is forgetting to use <$set>. If you don’t use update operators properly, you might accidentally overwrite the entire document.

Update operations are crucial in any database CRUD operations workflow because real-world data is constantly changing.

4. Delete Operations

The Delete operation in MongoDB is used to remove data from a collection. In real-world projects, this happens when a user deletes their account, an admin removes inactive users, or outdated products are cleared from the database. This is the final part of CRUD operations in MongoDB.

MongoDB provides <deleteOne()> and <deleteMany()> for handling delete-related MongoDB commands.

To delete a single document:

db.students.deleteOne({ name: "Rohit" })

This removes the first document that matches the condition.

To delete multiple documents:

db.students.deleteMany({ course: "MERN Stack" })

One important tip for beginners is to always double-check your filter condition before running delete commands. If you use an empty filter like {}, MongoDB will delete all documents in that collection.

Delete operations complete the cycle of CRUD operations. Once you understand Create, Read, Update, and Delete together, you have mastered the foundation of working with any CRUD database system.

How to Create Databases and Collections in MongoDB?

Here is a step-by-step guide to manually create databases and collections in MongoDB.

Step 1: Start the MongoDB Server

Make sure MongoDB is installed and running.

mongod

Then open another terminal and enter:

mongosh

This connects you to the MongoDB shell.

Step 2: Create or Switch to a Database

In MongoDB, a database is created automatically when you insert data into it. But first, you switch to a database using:

use studentDB

If <studentDB> does not exist, MongoDB will create it automatically when you add data. You can verify your database using:

show dbs

Step 3: Create a Collection

You can explicitly create a collection like this:

db.createCollection("students")

Or simply insert data, and MongoDB will create the collection automatically. For example:

db.students.insertOne({

age: 20,

course: "Web Development"

})

Now, both the database and collection are created if they did not exist earlier.

Step 4: Verify Collections

To check collections inside your database:

show collections

Best Practices for MongoDB CRUD Operations

If you don’t follow proper structure while performing CRUD operations in MongoDB, your app may become slow, messy, or difficult to maintain. Here are some practical best practices to keep your CRUD operations clean and scalable.

Always Use Proper Indexing

If you frequently search data using a field like <email>, <username>, or <course>, create an index on that field. Without indexing, MongoDB scans the entire collection, which slows down performance.

db.students.createIndex({ email: 1 })

Indexes make Read operations much faster in large-scale database systems.

Validate Data Before Inserting

Never blindly insert user data into the database. Validate inputs in your backend before performing any CRUD operation. Data validation ensures cleaner operations and prevents broken records. In Node.js:

const studentSchema = new mongoose.Schema({

age: { type: Number, min: 18 }

});

Avoid Updating Entire Documents

While performing update operations, always use update operators like <$set>. If you replace the entire document unintentionally, important fields might get deleted. This is a small habit that prevents major production mistakes.

{ $set: { age: 23 } }

Use Filters Carefully in Delete Operations

Many beginners accidentally wipe collections during practice. Always double-check your filter condition. Never run:

db.students.deleteMany({})

Handle Errors Properly

Error handling makes your CRUD implementation reliable and professional. In real applications, database operations may fail. Always use try-catch blocks in Node.js:

try {

const data = await Student.find();

} catch (error) {

console.error(error);

}

Limit Data When Reading

Fetching unnecessary data increases load and affects performance in larger CRUD operations. If you don’t need all records, use <.limit()> and proper filtering.

db.students.find().limit(10)

Final Words

If you understand Create, Read, Update, and Delete, you understand the core of backend development. Every login system, e-commerce platform, student portal, or admin dashboard runs on these basic CRUD operations in MongoDB.

MongoDB is especially powerful for beginners because it removes unnecessary complexity. You don’t need to design rigid tables before inserting data. You can focus on building features first and refine the structure as your application grows.

If you are building freelance projects or working on your first MERN stack application, strong fundamentals in CRUD will give you confidence.

Frequently Asked Questions (FAQs)

Q1. What are CRUD operations in MongoDB?

Ans. CRUD operations in MongoDB refer to the four basic database actions (Create, Read, Update, and Delete). These operations allow developers to insert data, retrieve data, modify existing records, and remove unwanted documents from a MongoDB collection. Every modern application relies on these core CRUD operations to manage its data.

Q2. Is MongoDB good for beginners learning CRUD operations?

Ans. Yes, MongoDB is beginner-friendly because it stores data in JSON-like documents, which are easy to understand for JavaScript developers. Unlike traditional SQL databases, MongoDB does not require complex table relationships in the beginning, making CRUD in MongoDB easier to practice.

Q3. What is the difference between SQL CRUD and MongoDB CRUD?

Ans. In SQL databases, CRUD operations are performed using structured queries like <INSERT>, <SELECT>, <UPDATE>, and <DELETE>. However, in MongoDB, CRUD operations use document-based commands like <InsertOne()> and <find()>. MongoDB provides more flexibility when handling semi-structured or unstructured data.

Q4. Do I need to create a database manually before performing CRUD operations?

Ans. No. In MongoDB, databases and collectionsare automatically created when you insert the first document. This makes MongoDB's CRUD setup simple and beginner-friendly compared to traditional CRUD database systems.