MongoDB Fundamentals

Your API works, but it forgets everything the moment you restart it. In-memory arrays were training wheels. Real applications need a database that survives crashes, stores gigabytes, and serves thousands of queries per second. For the MERN stack, that database is MongoDB.

MongoDB is a document database. Instead of tables and rows, it stores flexible JSON-like documents inside collections. This lesson covers the mental model, the shell, CRUD, and the GUI tool you will use daily.

SQL vs MongoDB, in one table

The concepts map cleanly:

"Schemaless" does not mean "no design". It means the database will not reject a document because it has an extra field — so your application must enforce structure. That is exactly what Mongoose does in the next lesson.

Documents, collections, and BSON

A MongoDB document is a set of key-value pairs, close to JSON:

{
  _id: ObjectId('665f1d2a9c1b4e0012a3b4c5'),
  title: 'Spirited Away',
  year: 2001,
  genres: ['animation', 'fantasy'],
  director: { name: 'Hayao Miyazaki' },
  createdAt: ISODate('2026-01-05T10:00:00Z')
}

Under the hood it is stored as BSON — binary JSON with types JSON lacks:

Every document gets an _id if you do not provide one, and it is unique within the collection. This is the field every reference and lookup will use.

Get a database in five minutes

You do not need to install anything locally. The free MongoDB Atlas tier (M0) is enough for every project in this curriculum:

1. Create an account at mongodb.com/atlas and create a free cluster (choose the region closest to you).
2. Under Database Access, create a user with a password.
3. Under Network Access, allow your current IP (or 0.0.0.0/0 for a throwaway dev cluster, never for production).
4. Click Connect → Drivers and copy the connection string:

mongodb+srv://USER:PASSWORD@cluster0.abcde.mongodb.net/library?retryWrites=true&w=majority

The part after the last / before ? is the database name. Keep this string in .env as MONGODB_URI and never commit it.

The shell: mongosh

mongosh is the interactive shell. Atlas offers a browser version (Cluster → Connect → Shell), or install it locally. It is the fastest way to inspect and edit data:

show dbs                       // list databases
use library                    // switch (creates on first write)
 
db.books.insertMany([
  { title: 'Dune', author: 'Frank Herbert', year: 1965, pages: 412, tags: ['sci-fi'] },
  { title: 'Neuromancer', author: 'William Gibson', year: 1984, pages: 271, tags: ['sci-fi', 'cyberpunk'] },
  { title: 'The Hobbit', author: 'J.R.R. Tolkien', year: 1937, pages: 310, tags: ['fantasy'] },
])

You just created the library database and the books collection implicitly. MongoDB creates them on first write — no CREATE TABLE ceremony.

Reading

db.books.find()                                    // everything
db.books.find({}, { title: 1, year: 1 })           // projection: only these fields (+_id)
db.books.findOne({ title: 'Dune' })                // one document
db.books.countDocuments({ tags: 'sci-fi' })        // count matching

Query operators replace your filter logic:

Sorting, pagination, and shaping:

db.books
  .find({ year: { $gte: 1950 } })
  .sort({ year: -1 })   // -1 descending, 1 ascending
  .skip(0)
  .limit(10)

Updating

db.books.updateOne(
  { title: 'Dune' },
  { $set: { rating: 4.8, updatedAt: new Date() } }
)
 
db.books.updateMany(
  { tags: 'sci-fi' },
  { $inc: { copiesSold: 1 } }   // increments a number
)
 
db.books.updateOne(
  { title: 'Dune' },
  { $push: { tags: 'classic' } } // appends to an array
)

Update operators you will use constantly: $set, $unset, $inc, $push, $pull, $addToSet. Without an operator, an update replaces the whole document — a common and painful mistake.

Deleting

db.books.deleteOne({ title: 'The Hobbit' })
db.books.deleteMany({ rating: { $lt: 2 } })

There is no undo. Take a backup or use a soft-delete field (deletedAt) for user-facing data.

Compass: the GUI

MongoDB Compass connects with the same connection string and gives you:

• A list of databases and collections with document counts.
• A visual query builder — filters, projections, sorts without syntax.
• Document editing, schema analysis, and a live index panel.
• An aggregation pipeline builder that shows results after each stage (invaluable for the next lessons).

Use the shell for speed and scripts; use Compass for exploring unfamiliar data and building queries visually.

The Node driver, briefly

Mongoose (next lesson) is the tool you will use in the API, but it is built on the official driver:

import { MongoClient } from 'mongodb'
 
const client = new MongoClient(process.env.MONGODB_URI)
await client.connect()
 
const books = client.db('library').collection('books')
const sciFi = await books.find({ tags: 'sci-fi' }).toArray()
 
console.log(sciFi)
await client.close()

This works, but you would end up writing schema validation, casting, and relationship logic by hand. Mongoose exists to do that for you.

Try it

use practice
 
db.movies.insertMany([
  { title: 'Akira', year: 1988, genres: ['animation'] },
  { title: 'Perfect Blue', year: 1997, genres: ['thriller'] },
  { title: 'Your Name', year: 2016, genres: ['romance'] },
])
 
db.movies.find({ year: { $gt: 1990 } }).sort({ year: 1 })
 
db.movies.updateOne({ title: 'Akira' }, { $set: { rating: 8.2 } })
 
db.movies.deleteOne({ title: 'Perfect Blue' })
 
db.movies.countDocuments()

Check your understanding

Summary

• MongoDB stores BSON documents in collections; no migrations, but your app must enforce shape.
• Every document has a unique _id; references are ObjectId values pointing at other documents.
• Atlas free tier gives you a cloud database in minutes; keep MONGODB_URI in .env.
• mongosh covers CRUD: insertMany, find, updateOne/updateMany, deleteOne, countDocuments.
• Query operators ($gte, $in, $regex, $or) replace most filter logic.
• Updates need operators ($set, $inc, $push); without one, the document is replaced.
• Compass visualizes data, builds queries, and will help you learn aggregation.

Next: Mongoose — schemas, validation, and models that turn these loose documents into a reliable data layer.