Week 1: MongoDB Fundamentals — Documents, Collections & CRUD

1. Why MongoDB? Documents vs. Rows

A relational database (like the SQL you'd use elsewhere) stores data in rigid rows with a fixed set of columns, defined up front. MongoDB stores documents — JSON-like objects that can nest arrays and other objects directly inside them, and don't require every document in a collection to share the exact same shape.

{
  "_id": ObjectId("64f1a2b3c4d5e6f7a8b9c0d1"),
  "name": "Asha Rao",
  "email": "asha@example.com",
  "tags": ["premium", "newsletter"],
  "address": {
    "city": "Kolkata",
    "state": "West Bengal"
  }
}

That nested address object and the tags array would each need a separate, joined table in a relational database. Here, a single document holds the whole related shape in one place — which is exactly why document databases are such a natural fit for data that's naturally hierarchical: user profiles, product catalogs, content management, event logs.

2. Installing MongoDB & Connecting with mongosh

Install MongoDB Community Server locally, or skip local installation entirely and use a free MongoDB Atlas cluster in the cloud — either works for this course. mongosh is the official shell you'll use to run every command below.

# macOS (Homebrew)
brew tap mongodb/brew
brew install mongodb-community mongosh

# Ubuntu/Debian -- follow MongoDB's official apt instructions for your version
# Windows -- install the MSI from mongodb.com/try/download/community

# Start the server (if running locally)
mongod --dbpath /path/to/your/data/directory

# In a separate terminal, connect with the shell
mongosh
# Current Mongosh Log ID: ...
# Connecting to: mongodb://127.0.0.1:27017/
# Using MongoDB: 7.0.x

Once connected, mongosh is a full JavaScript environment — every command in this lesson is really a JavaScript method call on a database or collection object.

3. Databases, Collections & Documents

A MongoDB server hosts multiple databases. Each database holds collections (the rough equivalent of a table). Each collection holds documents (the rough equivalent of a row).

// Switch to (or create) a database -- it's created on first write, not on this command
use school

// List every database that actually has data
show dbs

// List collections in the current database
show collections

// Explicitly create a collection (usually unnecessary -- insertOne does this automatically)
db.createCollection("students")

4. CRUD Operations: The Five You'll Use Constantly

Every one of MongoDB's dozens of methods is a variation on five core operations. Learn these five well and you can already do real work.

// CREATE -- insert one document
db.students.insertOne({ name: "Ben Diaz", grade: 9, gpa: 3.4 })

// CREATE -- insert many documents at once
db.students.insertMany([
  { name: "Chen Wei", grade: 10, gpa: 3.9 },
  { name: "Dev Patel", grade: 9, gpa: 2.8 }
])

// READ -- find every document
db.students.find()

// READ -- find with a filter, pretty-printed
db.students.find({ grade: 9 }).pretty()

// READ -- find exactly one document
db.students.findOne({ name: "Ben Diaz" })

// UPDATE -- modify one matching document
db.students.updateOne(
  { name: "Ben Diaz" },
  { $set: { gpa: 3.5 } }
)

// UPDATE -- modify every matching document
db.students.updateMany(
  { grade: 9 },
  { $set: { onProbation: false } }
)

// DELETE -- remove one matching document
db.students.deleteOne({ name: "Dev Patel" })

// DELETE -- remove every matching document
db.students.deleteMany({ grade: 9 })

5. The _id Field & BSON Types

Every document gets an _id field automatically if you don't provide one — it's the primary key, and it's required and unique within a collection. By default MongoDB generates an ObjectId: a 12-byte value that encodes a timestamp, so IDs are roughly sortable by creation time even without a separate date field.

db.students.insertOne({ name: "Eva Kim", grade: 11 })
// { acknowledged: true, insertedId: ObjectId("64f...") }

// You can supply your own _id instead, if it's meaningful in your domain
db.students.insertOne({ _id: "student-eva-kim", name: "Eva Kim", grade: 11 })

// Extract the creation time embedded in a default ObjectId
db.students.findOne({ name: "Eva Kim" })._id.getTimestamp()

Under the hood, MongoDB stores documents as BSON (Binary JSON) — a binary format that adds types plain JSON doesn't have, including ObjectId, native Date, and distinct integer/decimal number types. This is why a MongoDB document looks almost exactly like JSON but isn't literally JSON on disk.

6. Hands-on Exercise

7. Knowledge Check

Four quick questions. Expand each to check your answer.