MongoDB interview questions & answers

Ek filing cabinet socho jisme har customer ka apna folder hai. Ek folder me poori page ki details ho sakti hain, dusre me sirf ek sticky note — koi force nahi karta ki har folder me bilkul same printed form ho. Folder kholo aur us customer ki har cheez wahin, ek saath mil jaati hai. Ab saare customer folders ko ek drawer me daal do, aur kai drawers ko ek cabinet me.

MongoDB me, wo folder ek document hai — JSON-jaisa key/value object (andar se BSON, Binary JSON, ke roop me store hota hai). Documents se bhara ek drawer ek collection hai (lagbhag ek table), aur saari collections ko rakhne wala cabinet ek database hai. Badi baat: MongoDB ek NoSQL document database hai — ye data ko flexible documents ke roop me store karta hai, tables ki rigid rows me nahi. Ek hi collection ke do documents ke fields alag ho sakte hain, kyunki schema database level par enforce nahi hota. Har document ko ek unique _id apne aap milti hai.

🌍 Real-world example: Ek users collection me, ek document hai { _id: ObjectId('...'), name: 'Aisha', age: 25, skills: ['react','node'], address: { city: 'Delhi' } }. Dekho ise andar hi ek array aur ek sub-object nest kiya gaya hai — koi extra tables nahi, koi joins nahi. Ise padhne ke liye tum db.users.findOne({ name: 'Aisha' }) likhoge aur poora document ek hi baar me wapas mil jaayega.

💡 NoSQL = ek database jo SQL tables/rows use NAHI karta; yahan, ek document store.

💡 document = ek record — JSON-jaisa key/value ka set (wo folder).

💡 collection = documents ka ek group (≈ ek SQL table / wo drawer).

💡 BSON = Binary JSON, MongoDB ka on-disk format; Date aur ObjectId jaise extra types support karta hai.

MERN me kahan fit hota hai: MongoDB M hai — data layer. Tumhara React front-end aur Express/Node back-end data store aur fetch karne ke liye MongoDB se baat karte hain. Ye wo database hai jo server restart hone par bhi sab kuch yaad rakhta hai.

Kab shine karta hai: flexible, nested, tezi se badalta data — user profiles, product catalogs, embedded comments wale posts, jahan bhi shape aksar badalti ho ya naturally nest karti ho. Poora object ek query me padh lete ho, koi joins nahi chahiye.

Kab weak hai: bahut saari tables me faila heavily relational data jisme bahut JOINs ho, aur multi-row transactions jahan records ke beech strict consistency zaroori ho (classic banking-style ledgers). Un cases me ek relational SQL database (Postgres/MySQL) behtar fit hota hai.

Standard definition: MongoDB is a NoSQL document database that stores data as flexible, JSON-like documents (BSON) inside collections inside a database, with a unique _id per document and no enforced schema — it is the M (data layer) in the MERN stack and shines for flexible, nested, evolving data rather than heavily relational, multi-table transactional workloads.

// mongosh (MongoDB shell)

// A document = a JSON-like object (stored as BSON)
const user = {
  name: 'Aisha',
  age: 25,
  skills: ['react', 'node'],
  address: { city: 'Delhi' }
};

// documents -> collections -> database
db.users.insertOne(user);      // _id auto-generated

// read the whole document back, nested data included
db.users.findOne({ name: 'Aisha' });

Do tareeke socho paperwork store karne ke. Ek relational (SQL) database ek strict spreadsheet jaisa hai: har row me bilkul same columns, bilkul same order me hone chahiye. Kisi ek banda ka middle name add karna hai? Poori sheet ka structure sabke liye badalna padega. Ek document (NoSQL) database ek draaz bhare folders jaisa hai: har folder ek banda ke papers rakhta hai, aur ek folder me ek extra page ho sakta hai jo baaki me nahi hai — koi permission nahi chahiye.

MongoDB me (ek document NoSQL database) data flexible JSON-jaise documents ke roop me collections ke andar rehta hai. Koi fixed columns nahi — same collection ke do documents ke different fields ho sakte hain. SQL databases (Postgres, MySQL) iske badle tables of rows aur columns use karte hain ek fixed schema ke saath jo tum pehle define karte ho, aur wo tables ko JOINs se jodte hain. Ye raha wo mental map jo har interviewer chahta hai:

SQL term	MongoDB term
table	collection
row	document
column	field
JOIN	$lookup / embedding

🌍 Real-world example: Ek user ka profile uske 3 addresses ke saath. SQL me tum ek users table aur ek alag addresses table rakhoge, phir SELECT ... FROM users JOIN addresses ON addresses.user_id = users.id. MongoDB me tum bas addresses ko user document ke andar ek array ke roop me embed kar dete ho — db.users.findOne({ _id: 1 }) user AUR uske addresses ek hi read me wapas deta hai, koi join nahi chahiye.

💡 schema = tumhare data ki shape/rules (kaunse fields hain, unke types). SQL ise strictly enforce karta hai; MongoDB flexible hai (Mongoose tumhare app me ek add kar sakta hai).

💡 JOIN = do tables ki rows ko ek matching key par combine karna. MongoDB related data ko saath embed karna prefer karta hai, ya $lookup jab join zaroori ho.

💡 ACID = strong all-or-nothing transaction guarantees (Atomicity, Consistency, Isolation, Durability) — SQL ki traditional strength.

💡 vertical vs horizontal scaling = vertical = ek bada server (SQL ka usual raasta); horizontal = data ko kai servers par faila do (sharding — jahan document DBs chamakte hain).

Kaunsa kab use karein? SQL uthao jab data highly relational aur transaction-heavy ho — banking, strict consistency wale orders, many-to-many relationships. MongoDB jaisa document DB uthao jab data flexible, nested, tezi se evolve hone wala, ya ek unit ki tarah saath padha jaata ho — user profiles, product catalogs, feeds, real-time apps. Koi "behtar" nahi hai; trade hai SQL ka rigid structure + joins + strong ACID vs MongoDB ka flexible schema + easy nesting + horizontal scale.

Standard definition: SQL databases store data in tables of rows and columns with a fixed schema and use JOINs plus strong ACID transactions (scaling mostly vertically), while document NoSQL databases like MongoDB store flexible schema-free documents in collections, favour embedding/denormalization over joins, and scale horizontally — use SQL for highly relational, transaction-heavy data and document DBs for flexible, nested, rapidly-evolving data.

-- SQL: a fixed-schema row in a `users` table
INSERT INTO users (id, name, city) VALUES (1, 'Aarav', 'Delhi');
SELECT * FROM users WHERE city = 'Delhi';

// MongoDB: the equivalent document in a `users` collection
db.users.insertOne({ _id: 1, name: 'Aarav', address: { city: 'Delhi' } });
db.users.find({ 'address.city': 'Delhi' });

Kya bana rahe hain: Ek tasks CRUD app MongoDB par Mongoose ke saath end-to-end — database se connect karo, ek Task Schema + model define karo, phir Create / Read / Update / Delete asli documents ko asli queries se karo, saath mein ek filtered find aur ek sort+paginate query. Koi raw driver nahi, shell mein koi db.tasks.insertOne nahi — sab kuch Mongoose ke through jaise ek Node backend asli mein karta hai.

Ant tak tum ek task ki poori zindagi trace karoge: use create karo → wo _id ke saath save ho jaata hai → use wapas find karo → ek field ko $set se update karo → use delete karo — har step pe exact query AUR resulting document dekhte hue. Ye har MERN app ka data layer hai; yahi calls ek Express route mein wire kar do aur tumhare paas ek working API hai.

🌍 Real-world example: Ye bilkul wahi hai jo ek to-do app ka backend karta hai. POST /tasks Task.create({...}) call karta hai, GET /tasks Task.find() call karta hai, PATCH /tasks/:id Task.findByIdAndUpdate(...) call karta hai. Resource ko books, orders, ya users se badal do — wahi paanch methods.

💡 Mongoose = ek ODM (Object Data Modeling) library. Ye MongoDB (jo khud schemaless hai) ke upar schema, types, validation aur helper methods lagata hai. Tum models (Task) se baat karte ho, Mongoose collection (tasks) se baat karta hai.

💡 CRUD = Create, Read, Update, Delete — chaar cheezein jo har app apne data ke saath karta hai. Mongoose mein: create, find/findById, findByIdAndUpdate, findByIdAndDelete.

---

Step 0 — Mental model (pehle ye padho)

Teen layers ek ke upar ek:

• Database (taskdb) → collections rakhta hai.
• Collection (tasks) → documents rakhta hai (har task ke liye ek).
• Document → ek JSON-jaisa object jismein ek unique _id (ek ObjectId) hota hai.

Mongoose upar baithta hai: tum ek Schema likhte ho (shape + rules), use ek model (Task) banate ho, aur us model ki har method tasks collection par ek query chalati hai. Ek saved document bas ek model instance hai jo disk pe persist ho gaya. Chalo isse banate hain.

---

Step 1 — MongoDB se connect karo

Jab tak connect na ho, kuch kaam nahi karta. mongoose.connect(uri) connection pool kholta hai aur ek Promise deta hai:

const mongoose = require('mongoose');

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/taskdb');
  console.log('MongoDB connected');
}
main().catch(err => console.error(err));

Ho ye raha hai:

1. URI mongodb://127.0.0.1:27017/taskdb batata hai kahan (host + port 27017, Mongo ka default) aur kaunsa database (taskdb). Agar taskdb abhi exist nahi karta, to Mongo pehli baar likhne par use bana deta hai — koi setup nahi.
2. mongoose.connect(...) ek Promise deta hai, isliye hum await karte hain. Baaki sab kuch iske resolve hone ke baad chalna chahiye — isiliye hamari poori app main() ke andar rehti hai.
3. Top-level call par .catch(...) galat URI / server-down ko pakadta hai taaki process chupchaap crash na ho.

💡 Connection pool = Mongoose Mongo se kuch reusable sockets ek baar kholta hai, aur har query ek udhaar leti hai. Tum connect ek baar startup pe call karte ho, kabhi per-request nahi.

---

Step 2 — Ek Schema + model define karo

Schema blueprint hai: field names, types, aur rules. Model wo callable object hai jispe tum queries chalate ho:

const taskSchema = new mongoose.Schema({
  title:    { type: String, required: true },
  done:     { type: Boolean, default: false },
  priority: { type: Number, default: 3 },
  tags:     [String]
}, { timestamps: true });

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

Ho ye raha hai:

1. Har field ek type (String, Boolean, Number, [String] = strings ka array) aur options declare karta hai. required: true ka matlab Mongoose bina title ke save reject karega; default value bhar deta hai jab tum use chhod do.
2. { timestamps: true } Mongoose ko createdAt aur updatedAt Date fields auto-add karke current rakhne ko kehta hai — muft auditing.
3. mongoose.model('Task', taskSchema) schema ko 'Task' naam ke ek model mein compile karta hai. Mongoose us naam ko lowercase + plural karke collection chunta hai: Task → tasks collection. Ye classic gotcha hai — collection tasks hai, Task nahi.

💡 Schema vs model: schema rules hai (shape + validation); model doer hai (Task.create, Task.find). Ek schema → ek model → ek collection.

---

Step 3 — CREATE (Model.create) — ek document ka janm TRACE karo

const task = await Task.create({
  title: 'Write resume',
  priority: 1,
  tags: ['career', 'urgent']
});
console.log(task);

Trace karo:

1. Task.create({...}) hamare plain object ko leta hai, schema ke against validate karta hai (title hai? ✅), defaults bharta hai (done nahi bheja → false), aur use tasks collection mein insert karta hai.
2. Mongo ek unique _id (ek ObjectId) generate karta hai kyunki humne diya nahi. timestamps createdAt/updatedAt stamp karte hain.
3. create saved document return karta hai — ab uski _id aur defaults ke saath. Resulting document:

{
  _id: ObjectId('66b0a1f4c2a4e81d3c7f0a11'),
  title: 'Write resume',
  done: false,               // default bhar gaya
  priority: 1,
  tags: ['career', 'urgent'],
  createdAt: 2026-07-16T10:00:00.000Z,
  updatedAt: 2026-07-16T10:00:00.000Z,
  __v: 0
}

Wo _id wahi handle hai jise hum is exact task ko find, update, aur delete karne ke liye use karenge. Dimaag mein copy kar lo: 66b0a1f4...0a11. Neeche sab kuch isi document ke peeche hai.

💡 Task.create(obj) = new Task(obj) + .save() ek hi call mein. __v Mongoose ka internal version key hai — ignore karo.

---

Step 4 — READ (find + ek filtered find) — apna task wapas dhoondho

Pehle use wapas padhkar saabit karo ki wo asli mein disk pe hai, phir ek filtered query chalao:

// (a) SAARE tasks find karo
const all = await Task.find();

// (b) apni _id se EK find karo
const found = await Task.findById('66b0a1f4c2a4e81d3c7f0a11');

// (c) filtered find — unfinished, high-priority tasks
const urgent = await Task.find({ done: false, priority: { $lte: 2 } });

Ho ye raha hai:

1. Task.find() bina filter ke tasks ke har document ko ek array mein return karta hai. Task.find({...}) filter karta hai. Task.findById(id) findOne({ _id: id }) ka shorthand hai — single doc ya null deta hai.
2. (c) hi asli query skill hai: { done: false, priority: { $lte: 2 } } padha jaata hai "done false hai AUR priority ≤ 2". Multiple keys apne-aap AND ho jaati hain; $lte "less-than-or-equal" operator hai. Hamara task (done:false, priority:1) match karta hai — to urgent return karta hai:

[
  { _id: ObjectId('66b0a1f4...0a11'), title: 'Write resume', done: false, priority: 1, tags: ['career','urgent'], ... }
]

Read-back persistence saabit karta hai: humne object ko kisi variable mein restart ke aar-paar pakda nahi — findById ne use uski _id se tasks collection se fresh nikaala. Wo bach gaya kyunki wo database mein hai.

💡 Ek Mongoose query thenable hai — await ise chalata hai. Bina await ke tumhe ek Query object milta hai, documents nahi (ek common beginner bug: console.log(Task.find()) query print karta hai, data nahi).

---

Step 5 — UPDATE ($set via findByIdAndUpdate {new:true}) — ek field badlo

Ab apne task ko done maark karo aur uski priority badhao:

const updated = await Task.findByIdAndUpdate(
  '66b0a1f4c2a4e81d3c7f0a11',
  { $set: { done: true, priority: 5 } },
  { new: true }
);
console.log(updated);

Trace karo:

1. findByIdAndUpdate(id, update, options) doc ko _id se dhoondhta hai aur update apply karta hai.
2. $set sirf named fields (done, priority) badalta hai aur title, tags, createdAt ko chhodta hai. Ye important gotcha hai: agar tum raw update mein ek plain object bina operator ke bhejo, to MongoDB poora document replace kar deta hai. $set safe, surgical tarika hai. (Mongoose thoda zyada forgiving hai, par hamesha $set likho — interviewers ise dekhte hain.)
3. { new: true } Mongoose ko document update ke baad wala return karne ko kehta hai. Iske bina tumhe purana (pre-update) version milta hai — ek classic "meri updated value kyun nahi dikh rahi?" bug. Resulting document:

{
  _id: ObjectId('66b0a1f4...0a11'),
  title: 'Write resume',        // unchanged
  done: true,                   // $set apply hua
  priority: 5,                  // $set apply hua
  tags: ['career', 'urgent'],   // unchanged
  updatedAt: 2026-07-16T10:05:00.000Z,  // timestamps ne badhaya
  ...
}

Wahi _id, do fields badle, baaki sab intact. Ye ek targeted update hai.

💡 { new: true } = "mujhe fresh copy do." Default false hai (purani copy). Ise yaad rakho — ye #1 Mongoose update gotcha hai.

---

Step 6 — DELETE (findByIdAndDelete) — apna task hatao

const deleted = await Task.findByIdAndDelete('66b0a1f4c2a4e81d3c7f0a11');
console.log(deleted); // jo doc HATAYA GAYA (ya null agar na mile)

const gone = await Task.findById('66b0a1f4c2a4e81d3c7f0a11');
console.log(gone);    // null — wakai chala gaya

Trace karo:

1. findByIdAndDelete(id) matching document hatata hai aur deleted doc return karta hai (jo hataya use confirm karne mein kaam aata hai) — ya null agar wo id thi hi nahi.
2. Read-back findById(sameId) ab null return karta hai — proof ki document tasks collection se chala gaya. Ye loop band karta hai: create → doc _id ke saath exist karta hai → use find karo → use update karo → use delete karo → find null deta hai. Ek document, janm se maut tak, har query dikhayi gayi.

⚠️ Bulk cousins se savdhaan: Task.deleteMany({}) empty filter ke saath collection ke har task ko delete kar deta hai. deleteMany se pehle hamesha filter double-check karo.

---

Step 7 — Sort + paginate (list query jo asli apps ko chahiye)

Ek list screen kabhi saare rows nahi ugalti — wo high-priority tasks ka page 2 dikhati hai, newest first:

const page = 2, size = 10;
const tasks = await Task.find({ done: false })
  .sort({ priority: 1, createdAt: -1 })  // priority asc, phir newest first
  .skip((page - 1) * size)               // pehla page skip karo
  .limit(size);                          // 10 lo

Ho ye raha hai:

1. .sort({ priority: 1, createdAt: -1 }) — 1 = ascending, -1 = descending. Ye priority low→high sort karta hai, aur same priority ke andar newest-first.
2. Pagination = .skip((page-1)*size).limit(size). Page 2 ke liye size 10 ke saath: 10 skip, 10 lo → rows 11–20. General formula: skip = (page - 1) * size, limit = size.
3. Chaining order result nahi badalta — Mongoose ek query banata hai aur Mongo sort → skip → limit saath apply karta hai.

💡 skip deep pages ke liye slow ho jaata hai — Mongo abhi bhi har skipped doc ke aage chalta hai, to page 5000 mehnga hai. Bade datasets ke liye bade skips ke bajaye range-based paging (createdAt < lastSeen) prefer karo. Interviews mein ye zaroor bolo.

---

🔎 Poora flow (wiring ka recap)

1. Ek baar connect — startup pe await mongoose.connect(uri).
2. Ek baar model — Schema (shape + rules) → mongoose.model('Task', schema) → tasks collection.
3. Per request CRUD — Task.create (C), Task.find/findById (R), Task.findByIdAndUpdate(id, { $set }, { new: true }) (U), Task.findByIdAndDelete(id) (D), saath mein find().sort().skip().limit() lists ke liye.

Aur wo zindagi jo humne trace ki: create ek doc _id ke saath return karta hai → findById use nikaalta hai → $set do fields update karta hai ({new:true} fresh copy dikhata hai) → findByIdAndDelete use hatata hai → findById ab null deta hai. Wahi _id poore raste — yahi persistence loop hai, query-dar-query saabit.

---

🚀 Ise ek Express route mein wire karna (Express chapter ka bridge)

Upar har method seedha ek route handler mein fit ho jaata hai — model methods tumhare controllers ka body hain:

app.post('/tasks', async (req, res) => {
  const task = await Task.create(req.body);        // C
  res.status(201).json(task);
});
app.get('/tasks/:id', async (req, res) => {
  const task = await Task.findById(req.params.id); // R
  task ? res.json(task) : res.status(404).json({ error: 'Not found' });
});
app.patch('/tasks/:id', async (req, res) => {
  const task = await Task.findByIdAndUpdate(req.params.id, { $set: req.body }, { new: true }); // U
  res.json(task);
});
app.delete('/tasks/:id', async (req, res) => {
  await Task.findByIdAndDelete(req.params.id);     // D
  res.status(204).end();
});

Express layer sirf HTTP handle karta hai (route, params, status codes, JSON); data ka kaam bilkul wahi Mongoose calls hain jo tumne abhi likhi. Ye saaf split — web ke liye Express, data ke liye Mongoose — poora MERN backend hai.

---

✅ Jo tumne abhi seekha

• Ek baar connect mongoose.connect(uri) se (Promise-based, startup pe).
• Schema → model — new Schema({ field: type/options }) → mongoose.model('Task', schema); model naam Task → tasks collection.
• Create — Task.create({...}) validate karta hai, defaults bharta hai, _id generate karta hai, saved doc return karta hai.
• Read — find() / findById(id) / filtered find({ done:false, priority:{ $lte:2 } }).
• Update — findByIdAndUpdate(id, { $set: {...} }, { new: true }); $set = surgical (poora doc replace nahi), { new: true } = fresh copy return.
• Delete — findByIdAndDelete(id) hataya hua doc return karta hai; deleteMany({}) collection wipe kar deta hai (savdhaan!).
• Sort + paginate — .sort({ f:1/-1 }).skip((page-1)*size).limit(size); skip deep pages ke liye slow.
• Express ka bridge — yahi model calls tumhare route handlers ban jaate hain.

const mongoose = require('mongoose');

const taskSchema = new mongoose.Schema({
  title:    { type: String, required: true },
  done:     { type: Boolean, default: false },
  priority: { type: Number, default: 3 },
  tags:     [String]
}, { timestamps: true });

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

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/taskdb');
  console.log('MongoDB connected');

  // CREATE
  const task = await Task.create({
    title: 'Write resume',
    priority: 1,
    tags: ['career', 'urgent']
  });
  const id = task._id;
  console.log('created', task);

  // READ (all, by id, filtered)
  const all     = await Task.find();
  const found   = await Task.findById(id);
  const urgent  = await Task.find({ done: false, priority: { $lte: 2 } });
  console.log('urgent', urgent);

  // UPDATE ($set + { new: true })
  const updated = await Task.findByIdAndUpdate(
    id,
    { $set: { done: true, priority: 5 } },
    { new: true }
  );
  console.log('updated', updated);

  // SORT + PAGINATE (page 2, 10 per page)
  const page = 2, size = 10;
  const listed = await Task.find({ done: false })
    .sort({ priority: 1, createdAt: -1 })
    .skip((page - 1) * size)
    .limit(size);

  // DELETE
  const removed = await Task.findByIdAndDelete(id);
  const gone    = await Task.findById(id); // null
  console.log('gone?', gone);

  await mongoose.disconnect();
}
main().catch(err => console.error(err));