MongoDB Guide

A beginner-friendly guide to the leading NoSQL document database — from install to your first CRUD operations

1. What is MongoDB?

MongoDB is a popular NoSQL document database. Instead of storing data in rows and columns like PostgreSQL, it stores data as documents — self-contained JSON-like records grouped into collections. Each document can hold its own structure, which makes MongoDB flexible for data that changes shape.

📦 Analogy — Folders of Envelopes vs a Spreadsheet
A relational database is a giant spreadsheet: every row must have the same columns. MongoDB is a filing cabinet where each envelope (document) can contain whatever fits — one order with a discount, another without, one shipment with three items, another with five. You don't have to invent empty columns just because most envelopes don't use them.

🎯 Real-World Examples

Scenario	Why MongoDB
Content & CMS	Blog posts and articles naturally vary in structure
IoT & sensor data	Flexible schemas ingest many device shapes
Catalogs	Products with optional attributes — no sparse-column pain
Real-time analytics	Aggregation pipelines power instant dashboards

2. Why use MongoDB? (The Benefits)

🪶 Flexible schema
Documents can differ between records — evolve your data model without migrations.

🧑‍💻 Dev-friendly JSON
Easily maps to objects in JavaScript, Python, and most programming languages.

📈 Horizontal scaling
Splits data across servers (sharding) as you grow.

⚡ Fast iteration
No table definitions to manage — just insert and go.

🔎 Rich query language
Range, arrays, geospatial, and text search built in.

☁️ Managed cloud
MongoDB Atlas offers a free tier — zero infrastructure to run.

3. MongoDB vs PostgreSQL (Quick Example)

🗃️ Relational (PostgreSQL) — fixed columns

CREATE TABLE products (
      id SERIAL PRIMARY KEY,
      name TEXT,
      price NUMERIC,
      color TEXT,
      size TEXT   -- all rows share all columns
  );
INSERT INTO products (name, price, color, size) VALUES ('T-shirt', 20, 'blue', 'M');

🍃 Document (MongoDB) — self-contained docs

db.products.insertOne({
      name: "T-shirt",
      price: 20,
      details: { color: "blue", size: "M" }
  });
// another product can have totally different fields
db.products.insertOne({ name: "Hat", price: 12 });

⚖️ Analogy — Forms vs Free-Form Notes
Relational is a government form: the fields exist even when you leave them blank. MongoDB is free-form notes: you only write the fields you have. Both store information — they just model it differently, and different apps prefer different styles.

4. Core Concepts

5. Install MongoDB

Term	What it is
Database	A named container for collections
Collection	A group of documents (roughly a "table")
Document	A single JSON-like record (roughly a "row")
Field	A key/value pair inside a document (roughly a "column")
`_id`	The unique primary key MongoDB adds automatically to every document
Embedded doc / array	Nested objects inside a document — denormalized but fast
Aggregation pipeline	Chained stages (`$match`, `$group`) that transform data

Install on Linux (Ubuntu/Debian via apt)

MongoDB community self-licence repo. Add the official package repository, then:

$ sudo apt update
$ sudo apt install -y mongodb-org
$ sudo systemctl enable --now mongod
$ systemctl status mongod

Install on Windows

Run the MSI installer from mongodb.com/try/download/community. Check Install MongoDB as a Service — then MongoDB starts automatically.

> net start MongoDB

Or run via Docker (works everywhere)

$ docker run -d --name mongo -p 27017:27017 mongo

Published to port 27017 — the default Mongo server port.

6. Hands-on: Your First CRUD

🧪 A short session with mongosh

$ mongosh

// Create — insert a document
db.products.insertOne({ name: "Keyboard", price: 45 });

// Read — find everything (pretty-printed)
db.products.find().pretty()

// Read with a filter (matches the field)
db.products.find({ name: "Keyboard" })

// Update — set a field
db.products.updateOne(
      { name: "Keyboard" },
      { $set: { price: 49 } }
  );

// Delete — remove matches
db.products.deleteOne({ name: "Keyboard" });

mongosh is the modern MongoDB shell — type db to confirm you're connected.

7. Quick Reference

8. Best Practices & Next Steps

Command	What it does
`db.collection.insertOne({...})`	Insert one document
`db.collection.find({})`	Query documents
`db.collection.updateOne(filter, {$set:{...}})`	Update first matching doc
`db.collection.deleteOne(filter)`	Delete first matching doc
`db.collection.aggregate([...])`	Chained transform pipeline
`show dbs`	List databases
`use <db>`	Switch/select a database
`show collections`	List collections in current db

🔍 Index first
Put indexes on fields your queries filter frequently.

📦 Embed, don't normalize everything
Embed arrays/objects you always read TOGETHER; store large shared data separately.

🛡 Use schema validation
Flexible doesn't mean messy — add validation where it matters.

🔐 Enable auth
On real deployments, create users and enforce TLS; don't expose on a open network.

💾 Back up
mongodump / mongorestore for one-off copies; Atlas has built-in backups.

🧭 Go deeper
Next: indexes, aggregation pipelines, geospatial, replica sets, and MongoDB Atlas.

MongoDB trades rigid structure for flexibility — when your data grows, your documents grow with it.
Install it, insert a document, run a query, and you've met the most popular NoSQL store.

🍃 MongoDB Guide