Junior NoSQL & MongoDB Interview Questions (50 MCQs)

Question 1

What does the term 'NoSQL' usually refer to?

Accepted Answer

Databases that don't use the classic relational table model, like document or key-value stores

Answer

Databases that have no query language at all

Answer

A version of SQL that only runs on cloud servers

Answer

Databases that only keep data in memory

Question 2

Which NoSQL family does MongoDB belong to?

Accepted Answer

Document store

Answer

Wide-column store

Answer

Graph database

Answer

Time-series database

Question 3

Which product is a common example of a key-value database?

Accepted Answer

Redis

Answer

Neo4j

Answer

Elasticsearch

Answer

InfluxDB

Question 4

Apache Cassandra is usually classified as which type of database?

Accepted Answer

Wide-column store

Answer

Document store

Answer

Graph database

Answer

Search engine

Question 5

For multi-hop relationship queries like 'friends of friends' in a social network, which database type fits best?

Accepted Answer

A graph database like Neo4j

Answer

A key-value store like Redis

Answer

A time-series database like InfluxDB

Answer

A wide-column store like Cassandra

Question 6

Which database type is designed for storing sensor metrics recorded every few seconds with timestamps?

Accepted Answer

A time-series database like InfluxDB

Answer

A graph database like Neo4j

Answer

A search engine like Elasticsearch

Answer

A key-value store like Memcached

Question 7

What is the primary use case of Elasticsearch?

Accepted Answer

Full-text search and log analytics

Answer

Traversing complex relationships between nodes

Answer

Running fully ACID banking transactions

Answer

Caching sessions in memory

Question 8

What is a common difference between a relational database and a document store like MongoDB?

Accepted Answer

Documents in a collection can have different shapes, while rows in a SQL table share a fixed schema

Answer

MongoDB doesn't support indexes at all

Answer

Relational databases can't store text data

Answer

MongoDB only runs on a single server and can't scale

Question 9

In which scenario is a relational database usually a more sensible choice than NoSQL?

Accepted Answer

Highly relational data with complex joins and strong transactional needs

Answer

Storing billions of log events with varying structure

Answer

Caching API responses for a few seconds

Answer

Full-text search across millions of articles

Question 10

What is horizontal scaling, which many NoSQL databases are designed for?

Accepted Answer

Adding more servers and distributing data across them

Answer

Adding more CPU and RAM to a single server

Answer

Increasing the number of columns in each table

Answer

Compressing data to use less disk

Question 11

In what format does MongoDB store documents?

Accepted Answer

BSON, a binary JSON-like format with extra types

Answer

Plain JSON text without any conversion

Answer

Compressed XML

Answer

CSV with one row per document

Question 12

What does a MongoDB `ObjectId` consist of?

Accepted Answer

12 bytes: a 4-byte timestamp, a random value, and a counter

Answer

An auto-incrementing integer like AUTO_INCREMENT

Answer

A fully random 16-byte UUID v4

Answer

A SHA-1 hash of the document's contents

Question 13

What happens if you insert a document without specifying an `_id` field?

Accepted Answer

The driver or server automatically adds an `ObjectId` as `_id`

Answer

The insert is rejected with an error

Answer

The document is stored with no primary key

Answer

MongoDB assigns a sequential number starting at 1

Question 14

What are the MongoDB equivalents of a SQL 'table' and 'row'?

Accepted Answer

Collection and document

Answer

Database and field

Answer

Index and cursor

Answer

Shard and chunk

Question 15

Which MongoDB method inserts multiple documents in a single call?

Accepted Answer

`insertMany()`

Answer

`insertAll()`

Answer

`bulkCreate()`

Answer

`addDocuments()`

Question 16

What does `db.users.updateOne({ _id: 1 }, { $set: { name: 'Ali' } })` do?

Accepted Answer

It changes only the `name` field and leaves other fields untouched

Answer

It replaces the entire document with `{ name: 'Ali' }`

Answer

It creates a new document with `name` set to 'Ali'

Answer

It updates all documents that have a `name` field

Question 17

Which update atomically increments the `views` counter by 1?

Accepted Answer

`{ $inc: { views: 1 } }`

Answer

`{ $set: { views: 'views + 1' } }`

Answer

`{ $add: { views: 1 } }`

Answer

`{ $push: { views: 1 } }`

Question 18

What's the difference between `$push` and `$addToSet` in MongoDB?

Accepted Answer

`$addToSet` adds a value only if it's not already in the array; `$push` always appends

Answer

`$push` sorts the array but `$addToSet` doesn't

Answer

`$addToSet` replaces the array with the new value

Answer

There's no difference; they're aliases

Question 19

Which operator removes all array elements matching a condition?

Accepted Answer

`$pull`

Answer

`$pop`

Answer

`$unset`

Answer

`$slice`

Question 20

Which update removes the `tempToken` field from a document entirely?

Accepted Answer

`{ $unset: { tempToken: '' } }`

Answer

`{ $set: { tempToken: null } }`

Answer

`{ $pull: { tempToken: 1 } }`

Answer

`{ $delete: { tempToken: 1 } }`

Question 21

What does `db.orders.find({ status: { $in: ['paid', 'shipped'] } })` return?

Accepted Answer

Orders whose `status` is either 'paid' or 'shipped'

Answer

Orders whose `status` is both 'paid' and 'shipped'

Answer

Orders whose `status` is neither of the two

Answer

Only the first matching order

Question 22

Which query finds products with price at least 100 and below 500?

Accepted Answer

`find({ price: { $gte: 100, $lt: 500 } })`

Answer

`find({ price: { $gt: 100, $lte: 500 } })`

Answer

`find({ price: '>= 100 AND < 500' })`

Answer

`find({ $between: { price: [100, 500] } })`

Question 23

How do you find users whose `age` is under 18 or whose `role` is 'admin'?

Accepted Answer

`find({ $or: [{ age: { $lt: 18 } }, { role: 'admin' }] })`

Answer

`find({ age: { $lt: 18 }, role: 'admin' })`

Answer

`find({ $and: [{ age: { $lt: 18 } }, { role: 'admin' }] })`

Answer

`find({ age: { $or: [18, 'admin'] } })`

Question 24

Why do we sometimes need `$elemMatch` when querying an array of objects?

Accepted Answer

So all conditions must match the same array element, not different elements

Answer

Because arrays can't be queried without it

Answer

To sort array elements by the condition

Answer

To return only the first matching document

Question 25

If `tags` is an array, what does `find({ tags: 'mongodb' })` match?

Accepted Answer

Documents whose `tags` array contains 'mongodb'

Answer

Only documents where `tags` is exactly `['mongodb']`

Answer

No documents, since arrays can't be compared to strings

Answer

Documents whose first `tags` element is 'mongodb'

Question 26

What fields does `db.users.find({}, { name: 1, email: 1 })` return?

Accepted Answer

`name`, `email`, and `_id`

Answer

Only `name` and `email`

Answer

All fields except `name` and `email`

Answer

All fields sorted by `name`

Question 27

Which MongoDB projection causes an error?

Accepted Answer

`{ name: 1, password: 0 }`

Answer

`{ name: 1, _id: 0 }`

Answer

`{ password: 0 }`

Answer

`{ name: 1, email: 1 }`

Question 28

Which query gets the 10 newest posts by descending `createdAt`?

Accepted Answer

`find().sort({ createdAt: -1 }).limit(10)`

Answer

`find().sort({ createdAt: 1 }).limit(10)`

Answer

`find().limit(10).order('createdAt DESC')`

Answer

`find({ createdAt: -1 }).top(10)`

Question 29

What is the main problem with paginating using `skip()` on very deep pages?

Accepted Answer

The server still walks all skipped documents, so it slows down as the offset grows

Answer

`skip()` only works up to 100 documents

Answer

`skip()` randomizes the result order

Answer

`skip()` can't be combined with `sort()`

Question 30

What does the `upsert: true` option do in `updateOne()`?

Accepted Answer

Inserts a new document if no document matches the filter

Answer

Updates all matching documents instead of one

Answer

Takes a backup before updating

Answer

Deletes the old document and re-inserts it

Question 31

What's the difference between `updateOne()` and `updateMany()`?

Accepted Answer

`updateOne()` changes only the first matching document; `updateMany()` changes all of them

Answer

`updateMany()` changes several fields, `updateOne()` only one field

Answer

`updateOne()` is atomic but `updateMany()` isn't atomic even per document

Answer

`updateMany()` only works inside a transaction

Question 32

At what level are MongoDB write operations atomic by default?

Accepted Answer

At the single-document level, including its embedded documents

Answer

At the whole-collection level

Answer

At the whole-database level

Answer

There's no atomicity guarantee at all

Question 33

When is embedding a user's addresses inside the user document a good choice?

Accepted Answer

When addresses are few and almost always read together with the user

Answer

When each user has millions of addresses

Answer

When addresses are shared by thousands of users and updated independently

Answer

When addresses never need to be read

Question 34

When is referencing (storing another document's `_id`) better than embedding?

Accepted Answer

When related data is large, grows without bound, or is shared among many documents

Answer

When related data is small and always read with the parent

Answer

When we want to fetch everything in a single read

Answer

When the relationship is a small one-to-one

Question 35

What is the maximum size of a single MongoDB document?

Accepted Answer

16 MB

Answer

1 MB

Answer

64 MB

Answer

There is no limit

Question 36

What does running `db.logs.deleteMany({})` do?

Accepted Answer

Deletes all documents but keeps the collection and its indexes

Answer

Does nothing because the filter is empty

Answer

Drops the collection along with its indexes

Answer

Deletes only the first document

Question 37

What does MongoDB do if there's no index on the queried field?

Accepted Answer

Performs a collection scan (`COLLSCAN`) examining every document

Answer

Rejects the query with an error

Answer

Automatically creates a permanent index

Answer

Checks only the first 1000 documents

Question 38

What does `db.users.createIndex({ email: 1 }, { unique: true })` do?

Accepted Answer

Creates an ascending index on `email` and prevents duplicate emails

Answer

Keeps only the first user per email and deletes the rest

Answer

Encrypts the email values

Answer

Makes the `email` field required for all documents

Question 39

What is the main cost of adding many indexes to a collection?

Accepted Answer

Slower writes and more memory and disk usage

Answer

All reads become slower

Answer

The maximum document size shrinks

Answer

Replication stops working

Question 40

Which command shows whether a query used an index or did a collection scan?

Accepted Answer

`db.users.find({ email: 'a@b.com' }).explain('executionStats')`

Answer

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

Answer

`db.users.stats({ email: 'a@b.com' })`

Answer

`db.users.profile({ email: 'a@b.com' })`

Question 41

How does the MongoDB aggregation pipeline work?

Accepted Answer

Documents flow through a sequence of stages, each stage's output feeding the next

Answer

All stages run in parallel on the original data and results are merged

Answer

Only one stage is allowed per query

Answer

The pipeline only modifies data on disk and returns nothing

Question 42

What does the stage `{ $group: { _id: '$customerId', total: { $sum: '$amount' } } }` produce?

Accepted Answer

One document per customer with the sum of their order `amount`

Answer

A single document with the total `amount` of all orders

Answer

All orders with a new `total` field added

Answer

The number of orders per customer

Question 43

What does the `$unwind` stage do on an array field `items`?

Accepted Answer

Outputs a separate document for each array element

Answer

Converts the array to a string

Answer

Removes duplicate array elements

Answer

Merges arrays from multiple documents into one

Question 44

What does the `$lookup` aggregation stage do?

Accepted Answer

Pulls in related documents from another collection, like a left outer join

Answer

Builds an index on another collection

Answer

Copies documents into another collection

Answer

Searches all collections for a specific value

Question 45

What role does Mongoose play in a Node.js project?

Accepted Answer

An ODM that adds schemas, validation, and models on top of the MongoDB driver

Answer

A database engine that replaces MongoDB

Answer

A tool that converts MongoDB to SQL

Answer

A cloud hosting service for MongoDB

Question 46

In Mongoose, what does `email: { type: String, required: true }` do?

Accepted Answer

On `save()`, a ValidationError is thrown if `email` is missing

Answer

Creates a unique index on `email` in the database

Answer

The MongoDB server itself rejects documents without `email`

Answer

Automatically fills `email` with an empty string

Question 47

What does eventual consistency mean?

Accepted Answer

If no new writes occur, all replicas eventually converge, but reads may briefly return stale data

Answer

Data is never synchronized between replicas

Answer

Every read always returns the latest write

Answer

Writes are only applied at the end of the day

Question 48

What do the three letters of the CAP theorem stand for?

Accepted Answer

Consistency, Availability, and Partition tolerance

Answer

Concurrency, Atomicity, and Performance

Answer

Caching, Availability, and Persistence

Answer

Consistency, Accuracy, and Partitioning

Question 49

What is the main purpose of a MongoDB replica set?

Accepted Answer

High availability and redundancy by keeping copies of data on multiple servers

Answer

Splitting data across servers to increase write capacity

Answer

Compressing data to reduce disk usage

Answer

Running SQL queries against MongoDB

Question 50

What can a DynamoDB table's primary key consist of?

Accepted Answer

Either just a partition key, or a partition key plus a sort key

Answer

Any number of columns like a SQL composite key

Answer

Only an auto-incrementing number

Answer

Always three parts: partition, sort, and timestamp