Middle NoSQL & MongoDB Interview Questions (50 MCQs)

Question 1

Per the ESR rule, which compound index best serves `find({ status: 'A', price: { $gt: 10 } }).sort({ createdAt: -1 })`?

Accepted Answer

`{ status: 1, createdAt: -1, price: 1 }`

Answer

`{ price: 1, status: 1, createdAt: -1 }`

Answer

`{ createdAt: -1, price: 1, status: 1 }`

Answer

`{ status: 1, price: 1, createdAt: -1 }`

Question 2

Given the index `{ a: 1, b: 1, c: 1 }`, which query cannot use it efficiently?

Accepted Answer

`find({ b: 5, c: 7 })`

Answer

`find({ a: 1 })`

Answer

`find({ a: 1, b: 5, c: 7 })`

Answer

`find({ a: 1 }).sort({ b: 1 })`

Question 3

What kind of index does MongoDB create when you index an array field?

Accepted Answer

A multikey index with a separate key for each array element

Answer

A single key for the whole serialized array

Answer

No index, since arrays can't be indexed

Answer

An automatic text index

Question 4

What is the restriction on compound multikey indexes in MongoDB?

Accepted Answer

In each document, at most one of the indexed fields may be an array

Answer

A compound index can't include any array field

Answer

At most two fields are allowed in a compound multikey index

Answer

Only numeric arrays can be indexed

Question 5

Which statement about TTL indexes in MongoDB is true?

Accepted Answer

It's defined on a `Date` field, and a background thread removes expired docs roughly every 60 seconds

Answer

Documents are deleted at exactly the second they expire

Answer

It works on any field type, including strings

Answer

Expired documents are just hidden from queries but never deleted

Question 6

Which is true about text indexes in (self-managed) MongoDB?

Accepted Answer

Each collection can have at most one text index, which may cover multiple fields

Answer

Every field can have its own separate text index

Answer

Text indexes support advanced fuzzy search and autocomplete

Answer

Text indexes are used only with `$regex`

Question 7

What's the benefit of a partial index like `createIndex({ email: 1 }, { partialFilterExpression: { active: true } })`?

Accepted Answer

It only indexes documents matching the filter, so the index is smaller and writes are cheaper

Answer

Queries on all documents get faster even without the `active` condition

Answer

It automatically deletes inactive documents

Answer

It keeps the index only in memory

Question 8

How does a sparse index behave in MongoDB?

Accepted Answer

It only indexes documents that contain the indexed field

Answer

It indexes only every tenth document

Answer

It indexes null values twice

Answer

It spreads the index across multiple shards

Question 9

Given the index `{ email: 1, name: 1 }`, which query is a covered query?

Accepted Answer

`find({ email: 'a@b.com' }, { name: 1, _id: 0 })`

Answer

`find({ email: 'a@b.com' }, { name: 1 })`

Answer

`find({ email: 'a@b.com' })`

Answer

`find({ name: 'Ali' }, { age: 1, _id: 0 })`

Question 10

In `explain('executionStats')` output, `totalDocsExamined: 500000` and `nReturned: 20`. What does this indicate?

Accepted Answer

There's no suitable or selective index, and the query is very inefficient

Answer

The query is perfectly optimized

Answer

The query is a covered query

Answer

The results came from a cache

Question 11

Which sort can the index `{ a: 1, b: -1 }` support without an in-memory SORT?

Accepted Answer

`sort({ a: -1, b: 1 })`

Answer

`sort({ a: 1, b: 1 })`

Answer

`sort({ a: -1, b: -1 })`

Answer

`sort({ b: -1, a: 1 })`

Question 12

Why is it important to put `$match` at the start of an aggregation pipeline?

Accepted Answer

It can use an index and reduces the documents flowing into later stages

Answer

Because `$match` is only allowed as the first stage

Answer

Because `$match` also sorts the results

Answer

Because `$group` fails without it

Question 13

When `$sort` immediately precedes `$limit`, what does MongoDB's optimizer do?

Accepted Answer

Coalesces them so the sort only keeps the top N documents in memory

Answer

Ignores the `$limit`

Answer

Swaps them so the limit is applied first

Answer

Sorts the full dataset on disk

Question 14

What happens if a `$group` or `$sort` stage needs more than 100 MB of RAM?

Accepted Answer

Without `allowDiskUse` it errors; with it, temporary data spills to disk

Answer

MongoDB silently truncates results to 100 MB

Answer

The query is moved to a secondary

Answer

The stage is skipped

Question 15

For a fast `$lookup` with `localField`/`foreignField`, which index matters?

Accepted Answer

An index on the `foreignField` in the `from` collection

Answer

An index on the `localField` in the source collection

Answer

A text index on both collections

Answer

None; `$lookup` always scans the whole collection

Question 16

What is the `$facet` stage useful for?

Accepted Answer

Running multiple sub-pipelines on the same input in one query, e.g., page results and total count together

Answer

Building an index on aggregation results

Answer

Splitting a collection across shards

Answer

Splitting a document into multiple files

Question 17

How should you model a host that has millions of log messages?

Accepted Answer

Each log in its own collection with a `hostId` field pointing to the host

Answer

An array of all logs embedded in each host document

Answer

An array of all log `_id`s inside each host document

Answer

All hosts and logs in a single document

Question 18

What's a common way to model a bounded many-to-many relationship between students and courses in MongoDB?

Accepted Answer

Store arrays of `_id`s on one or both sides, like `courseIds` on the student

Answer

Fully embed each course with all its students inside every student

Answer

MongoDB doesn't support many-to-many relationships

Answer

Create a separate collection per course

Question 19

Why are unbounded arrays, like an ever-growing `comments` array, an anti-pattern?

Accepted Answer

The document bloats toward 16 MB, and multikey indexes and reads/writes get slow

Answer

MongoDB rejects arrays with more than 100 elements

Answer

Arrays aren't replicated in a replica set

Answer

Arrays can't be indexed

Question 20

What is the bucket pattern in MongoDB?

Accepted Answer

Grouping multiple records (e.g., one sensor's readings for an hour) into one document with a bounded array

Answer

Storing each document on its own shard

Answer

Splitting a large document into GridFS files

Answer

Creating a separate collection per user

Question 21

In the subset pattern for a product page with thousands of reviews, what gets embedded?

Accepted Answer

Only a few recent or top reviews, with the rest in a separate collection

Answer

All reviews inside the product document

Answer

No reviews; only their count

Answer

The product inside every review

Question 22

In the extended reference pattern, why copy the customer's `name` and `address` into the order alongside `customerId`?

Accepted Answer

So frequent order reads don't need a `$lookup`, accepting some data duplication

Answer

Because MongoDB won't accept `customerId` without them

Answer

To make the document smaller

Answer

Because references aren't supported in MongoDB

Question 23

How does the schema versioning pattern work in MongoDB?

Accepted Answer

Each document carries a field like `schemaVersion`, and the app handles each version and upgrades gradually

Answer

MongoDB creates a separate collection per schema version

Answer

Every schema change locks and rewrites the whole collection

Answer

The schema version is stored in the database name

Question 24

In a 'lazy' migration in a schemaless store, when are documents converted to the new shape?

Accepted Answer

When the application next reads or updates them

Answer

All at once in one big transaction at deploy time

Answer

Never; old data is deleted

Answer

Only when the database server restarts

Question 25

How can you enforce structural rules like required fields in the MongoDB server itself?

Accepted Answer

With a `$jsonSchema` collection validator via `collMod` or `createCollection`

Answer

MongoDB has no server-side validation mechanism

Answer

Only via Mongoose

Answer

By creating unique indexes on every field

Question 26

What is required to use multi-document transactions in MongoDB?

Accepted Answer

A replica set or sharded cluster deployment, and using a session

Answer

A standalone instance is enough

Answer

Enabling text indexes on all collections

Answer

Using Mongoose

Question 27

Why are long-running transactions discouraged in MongoDB?

Accepted Answer

By default they abort after 60 seconds and add WiredTiger cache pressure and conflict risk

Answer

Transactions can modify at most one document

Answer

Transactions aren't durable

Answer

Long transactions lock the entire database

Question 28

What does write concern `{ w: 'majority' }` guarantee?

Accepted Answer

The write is acknowledged only after a majority of voting replica set members have applied it

Answer

The write is applied on all members including arbiters

Answer

The write is only in the primary's memory

Answer

The write is sent with no acknowledgement

Question 29

What's the risk of using `{ w: 1 }` in a replica set?

Accepted Answer

If the primary fails before replicating, the acknowledged write may be rolled back

Answer

Writes never reach the secondaries

Answer

Each write is applied twice

Answer

Writes only go to a secondary

Question 30

What does `j: true` mean in a write concern?

Accepted Answer

Acknowledgement waits until the write is recorded in the on-disk journal

Answer

The write is stored as JSON

Answer

The write is recorded in the audit log

Answer

The write goes to a secondary instead of the primary

Question 31

What's a consequence of using the `secondaryPreferred` read preference?

Accepted Answer

Read load shifts off the primary, but you may read stale data due to replication lag

Answer

All reads always return the latest data

Answer

Writes are also routed to secondaries

Answer

The cluster's write capacity doubles

Question 32

What does read concern `'majority'` guarantee?

Accepted Answer

Only data acknowledged by a majority, which won't be rolled back, is returned

Answer

The read is performed on a majority of nodes and merged

Answer

Always returns the newest write, even unacknowledged

Answer

The read is served only by an arbiter

Question 33

Why is a two-member replica set (no arbiter) unsuitable for high availability?

Accepted Answer

If one member goes down, the survivor lacks a majority of votes and can't become primary

Answer

Two members cause every write to happen twice

Answer

MongoDB requires at least five members

Answer

Two members can't replicate data

Question 34

What is the oplog in a replica set?

Accepted Answer

A capped collection recording the primary's writes so secondaries can apply them

Answer

A log of slow queries

Answer

The replica set configuration file

Answer

The list of users and permissions

Question 35

In a MongoDB sharded cluster, what is the role of `mongos`?

Accepted Answer

A stateless router that uses config server metadata to route queries to the right shards

Answer

A shard that holds a backup of all data

Answer

A process that only manages elections between shards

Answer

A command-line tool for importing data

Question 36

Which statement about MongoDB change streams is true?

Accepted Answer

They require a replica set or sharded cluster, and a resume token lets you continue after a disconnect

Answer

They work on a standalone instance too

Answer

They only report schema changes

Answer

They're implemented by periodically polling the collection

Question 37

How does `Post.find().populate('author')` work in Mongoose?

Accepted Answer

It runs a separate query on the authors collection with `$in` and replaces references with documents

Answer

It runs a single server-side `$lookup`

Answer

It permanently copies author data into the post

Answer

It only works on embedded fields

Question 38

What effect does `.lean()` have on a Mongoose query?

Accepted Answer

Returns plain JavaScript objects instead of Mongoose documents, faster and lighter

Answer

Returns only indexed fields

Answer

Runs the query on a secondary

Answer

Compresses the result

Question 39

Why might `Model.updateOne({ _id }, { age: -5 })` succeed even though the schema has `min: 0`?

Accepted Answer

Validators don't run on update queries by default unless `runValidators: true` is set

Answer

`min` only works for strings

Answer

Mongoose always ignores validation

Answer

Because `_id` is in the filter

Question 40

By default, which version of the document does `findOneAndUpdate()` return in the MongoDB driver?

Accepted Answer

The pre-update version, unless you pass `returnDocument: 'after'`

Answer

Always the post-update version

Answer

Both versions in an array

Answer

Only the count of modified documents

Question 41

What's the advantage of `bulkWrite()` over sending thousands of separate `updateOne()` calls?

Accepted Answer

It batches operations, drastically reducing network round trips

Answer

It runs all operations as one atomic transaction

Answer

It disables validation

Answer

It temporarily drops indexes

Question 42

How do you find documents where `spent` is greater than the same document's `budget`?

Accepted Answer

`find({ $expr: { $gt: ['$spent', '$budget'] } })`

Answer

`find({ spent: { $gt: 'budget' } })`

Answer

`find({ spent: { $gt: '$budget' } })`

Answer

`find({ $where: { spent: '>budget' } })`

Question 43

How do you update all elements of the `items` array whose `qty` is zero?

Accepted Answer

`$set: { 'items.$[el].status': 'out' }` with `arrayFilters: [{ 'el.qty': 0 }]`

Answer

`$set: { 'items.$.status': 'out' }`, which updates all matching elements

Answer

`$set: { 'items.status': 'out' }`

Answer

You must read the whole array, modify it in the app, and write it back

Question 44

How can you keep only the latest 50 activities in a `recent` array?

Accepted Answer

`$push: { recent: { $each: [item], $slice: -50 } }`

Answer

`$push: { recent: item, $limit: 50 }`

Answer

`$addToSet: { recent: item, $max: 50 }`

Answer

With a TTL index on the array

Question 45

In Cassandra with `PRIMARY KEY ((user_id), created_at)`, what is the role of `created_at`?

Accepted Answer

A clustering key that orders rows within each partition

Answer

Part of the partition key that decides the storing node

Answer

An automatic secondary index

Answer

The rows' TTL

Question 46

What is the right approach to data modeling in Cassandra?

Accepted Answer

Query-first: design a denormalized table for each query pattern

Answer

Fully normalize and use joins at query time

Answer

One table and `ALLOW FILTERING` for every query

Answer

Rely on secondary indexes for every field

Question 47

What's the difference between `Query` and `Scan` in DynamoDB?

Accepted Answer

`Query` reads one partition given a partition key; `Scan` reads the entire table

Answer

`Scan` is faster because it bypasses the index

Answer

`Query` only works on GSIs

Answer

They cost the same

Question 48

Which statement about a DynamoDB Global Secondary Index (GSI) is true?

Accepted Answer

It can have a different partition key, can be added anytime, and supports only eventually consistent reads

Answer

It must be defined at table creation and share the table's partition key

Answer

It supports strongly consistent reads

Answer

It adds no extra write cost

Question 49

Why can Elasticsearch perform full-text search quickly?

Accepted Answer

It uses an inverted index mapping each term to the list of documents containing it

Answer

It sequentially scans all documents in memory

Answer

It uses a B-tree on each document's full text

Answer

It stores all documents in a single file

Question 50

In Elasticsearch, why should a `status` field used for exact filtering and aggregations be `keyword`, not `text`?

Accepted Answer

`text` is analyzed into terms, while `keyword` keeps the exact value for exact matches, sorting, and aggregations

Answer

`keyword` just compresses better but behaves the same

Answer

`text` is only for numbers

Answer

`keyword` enables fuzzy search