A Beginner's Guide to Setting Up MongoDB with Node.js

Surya Deekshith — Tue, 03 Nov 2026 13:44:52 +0000

Learn how to connect Node.js to MongoDB, create a database, model data with Mongoose, and build a simple CRUD API — step by step.
MongoDB and Node.js are one of the most popular combinations for building modern backend applications. MongoDB stores data as flexible JSON-like documents, while Node.js lets you build fast JavaScript-powered servers. Together, they are a great starting point for full-stack development.
In this guide, you will set up MongoDB with Node.js from scratch and build a small Tasks API that can create, read, update, and delete tasks.

By the end, you will know how to:
1.Set up a Node.js project
2.Connect to MongoDB using Mongoose
3.Create a schema and model
4.Build CRUD endpoints with Express
5.Store credentials safely with environment variables
6.Avoid common beginner mistakes

MongoDB’s official Node.js driver supports connecting to MongoDB Atlas or a local MongoDB instance, and Mongoose is a widely used ODM that adds schemas, validation, and model-based data access on top of MongoDB.
Prerequisites
Before starting, install the following:

Node.js — version 16.20.1 or later is recommended by MongoDB’s current Node.js driver documentation.
npm — installed automatically with Node.js. 3.MongoDB Atlas account — the easiest free way to host a database in the cloud. 4.Code editor — VS Code is a good choice.
Basic JavaScript knowledge — especially async/await, objects, and arrays. You do not need to install MongoDB locally for this tutorial. We will use MongoDB Atlas, MongoDB’s managed cloud database service.

What You Will Build
You will create a simple REST API for managing tasks.

Each task will contain:
{
"title": "Learn MongoDB",
"completed": false
}

Step 1: Create the Node.js Project
Open your terminal and run:
mkdir node-mongodb-tasks-api
cd node-mongodb-tasks-api
npm init -y

This creates a folder and a package.json file.
Now install the required dependencies:

npm install express mongoose dotenv
npm install -D nodemon

Here is what each package does:
1.express — creates the web server and API routes.
2.mongoose — connects Node.js to MongoDB and helps define data models.
3.dotenv — loads secret values from a .env file.
4.nodemon — automatically restarts the server when you change code.
Open package.json and update the scripts section:
"scripts": {
"start": "node server.js",
"dev": "nodemon server.js"
}

You can now start your project in development mode with:

npm run dev

Step 2: Set Up MongoDB Atlas
MongoDB Atlas is a cloud-hosted MongoDB service. It is ideal for beginners because you do not need to configure a local database server.
1.Go to MongoDB Atlas.
2.Create a free account.
3.Create a free M0 cluster.
4.Create a database user with a username and password.
5.Add your current IP address to the network access list.
6.Click Connect.
7.Choose Drivers.
8.Select Node.js.
9.Copy the connection string.
MongoDB’s documentation recommends creating a database user, adding your IP address to the access list, and selecting the Node.js driver to obtain a connection string.
Your connection string will look similar to this:

mongodb+srv://:@cluster0.xxxxx.mongodb.net/?retryWrites=true&w=majority

Replace and with your actual database credentials.

Step 3: Store Secrets in a .env File
Never put your database password directly in your code.
Create a file named .env in your project root:
PORT=5000
MONGODB_URI=mongodb+srv://your_username:your_password@cluster0.xxxxx.mongodb.net/taskdb?retryWrites=true&w=majority

Create another file named .gitignore:
node_modules
.env
This prevents your secrets and dependencies from being uploaded to GitHub.

Step 4: Connect Node.js to MongoDB
Create a file named server.js:

import express from "express";
import mongoose from "mongoose";
import dotenv from "dotenv";

dotenv.config();

const app = express();

app.use(express.json());

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

mongoose
.connect(MONGODB_URI)
.then(() => {
console.log("Connected to MongoDB");

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

})
.catch((error) => {
console.error("MongoDB connection failed:", error.message);
process.exit(1);
});

Add this to your package.json so Node.js can use modern import syntax:
"type": "module"
Now run:
npm run dev
If everything is correct, you should see:
Connected to MongoDB
Server running on port 5000

Mongoose’s official getting-started guide uses mongoose.connect() to open a connection to MongoDB, and MongoDB’s own Mongoose tutorial follows the same connection approach.

Step 5: Create a Mongoose Schema
A schema describes the structure of your data.
Create a folder called models, then create a file inside it called Task.js:

import mongoose from "mongoose";

const taskSchema = new mongoose.Schema(
{
title: {
type: String,
required: [true, "Task title is required"],
trim: true,
maxlength: [100, "Title cannot exceed 100 characters"]
},
completed: {
type: Boolean,
default: false
}
},
{
timestamps: true
}
);

const Task = mongoose.model("Task", taskSchema);

export default Task;

What This Does
1.title must be a string and is required.
2.completed defaults to false.
3.timestamps: true automatically adds createdAt and updatedAt fields.
4.mongoose.model() creates the Task model, which you will use to query the database.
Mongoose helps enforce a semi-rigid schema at the application level, which is useful when you want more structure and validation than raw MongoDB documents provide.

Step 6: Build the CRUD Routes
Create a folder named routes, then create a file called taskRoutes.js:
import express from "express";
import Task from "../models/Task.js";

const router = express.Router();

// Create a task
router.post("/", async (req, res) => {
try {
const task = await Task.create(req.body);
res.status(201).json(task);
} catch (error) {
res.status(400).json({ error: error.message });
}
});

// Get all tasks
router.get("/", async (req, res) => {
try {
const tasks = await Task.find().sort({ createdAt: -1 });
res.json(tasks);
} catch (error) {
res.status(500).json({ error: error.message });
}
});

// Get one task
router.get("/:id", async (req, res) => {
try {
const task = await Task.findById(req.params.id);

if (!task) {
  return res.status(404).json({ error: "Task not found" });
}

res.json(task);

} catch (error) {
res.status(400).json({ error: "Invalid task ID" });
}
});

// Update a task
router.put("/:id", async (req, res) => {
try {
const task = await Task.findByIdAndUpdate(req.params.id, req.body, {
new: true,
runValidators: true
});

if (!task) {
  return res.status(404).json({ error: "Task not found" });
}

res.json(task);

} catch (error) {
res.status(400).json({ error: error.message });
}
});

// Delete a task
router.delete("/:id", async (req, res) => {
try {
const task = await Task.findByIdAndDelete(req.params.id);

if (!task) {
  return res.status(404).json({ error: "Task not found" });
}

res.json({ message: "Task deleted successfully" });

} catch (error) {
res.status(400).json({ error: "Invalid task ID" });
}
});

export default router;

Step 7: Connect Routes to the Server
Update server.js:
import express from "express";
import mongoose from "mongoose";
import dotenv from "dotenv";
import taskRoutes from "./routes/taskRoutes.js";

dotenv.config();

const app = express();

app.use(express.json());
app.use("/api/tasks", taskRoutes);

app.get("/", (req, res) => {
res.json({ message: "Welcome to the Task API" });
});

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

mongoose
.connect(MONGODB_URI)
.then(() => {
console.log("Connected to MongoDB");

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

})
.catch((error) => {
console.error("MongoDB connection failed:", error.message);
process.exit(1);
});

Your project structure should now look like this:

node-mongodb-tasks-api/
├── models/
│ └── Task.js
├── routes/
│ └── taskRoutes.js
├── .env
├── .gitignore
├── package.json
└── server.js

Step 8: Test the API
npm run dev
You can test the API using Postman, Insomnia, or curl.
Create a Task
curl -X POST http://localhost:5000/api/tasks \
-H "Content-Type: application/json" \
-d '{"title":"Learn MongoDB with Node.js"
Expected response:
{
"id": "65f1a2b3c4d5e6f7a8b9c0d1",
"title": "Learn MongoDB with Node.js",
"completed": false,
"createdAt": "2026-11-03T13:00:00.000Z",
"updatedAt": "2026-11-03T13:00:00.000Z",
"_v": 0
}

Get All Tasks
curl http://localhost:5000/api/tasks
Update a Task
curl -X PUT http://localhost:5000/api/tasks/YOUR_TASK_ID \
-H "Content-Type: application/json" \
-d '{"completed":true}'

Delete a Task
curl -X DELETE http://localhost:5000/api/tasks/YOUR_TASK_ID

Common Beginner Mistakes

Exposing Your Database Password
Never commit your .env file to GitHub.
Always add this to .gitignore:
".env"
Forgetting express.json()
Without this middleware, Express cannot read JSON request bodies:

app.use(express.json());

Using the Wrong Connection String Make sure you copied the Node.js driver connection string from MongoDB Atlas, not another language’s connection string.
Not Handling Errors Database operations can fail. Always use try/catch around asynchronous MongoDB operations.

Next Steps
Once this works, try improving the project:
1.Add validation for empty titles.
2.Add filtering: GET /api/tasks?completed=true.
3.Add pagination using limit and skip.
4.Add user authentication with JWT.
5.Deploy the API to Render, Railway, or Vercel.
6.Connect it to a React frontend.
Final Project Code
Your complete server.js should look like this:
import express from "express";
import mongoose from "mongoose";
import dotenv from "dotenv";
import taskRoutes from "./routes/taskRoutes.js";

dotenv.config();

const app = express();

app.use(express.json());
app.use("/api/tasks", taskRoutes);

app.get("/", (req, res) => {
res.json({ message: "Welcome to the Task API" });
});

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

mongoose
.connect(MONGODB_URI)
.then(() => {
console.log("Connected to MongoDB");

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

})
.catch((error) => {
console.error("MongoDB connection failed:", error.message);
process.exit(1);
});

Conclusion
You have now built a complete Node.js and MongoDB backend from scratch. You learned how to connect to MongoDB Atlas, define a Mongoose schema, create a model, and build a working CRUD API with Express.
This is a strong foundation for building real applications such as blogs, e-commerce platforms, task managers, and SaaS products.
If you found this helpful, follow me for more beginner-friendly Node.js, MongoDB, and backend development tutorials.

DEV Community: Surya Deekshith

A Beginner's Guide to Setting Up MongoDB with Node.js