MongoDB Quiz ( Advance ) - All Questions

This advanced MongoDB quiz is built for experienced backend engineers and database professionals preparing for senior-level interviews. It covers deep concepts like aggregation optimization, indexing strategies, transactions, sharding internals, replication behavior, performance tuning, and real-world production challenges.

Question 1: Why can poorly designed indexes degrade MongoDB write performance?

Indexes consume network bandwidth
Indexes increase memory fragmentation
Indexes must be updated on every write
Indexes block read operations

Explanation: Every write must update all relevant indexes, slowing write performance.

Question 2: What happens when a MongoDB query cannot use an index?

Query fails
Collection scan occurs
Shard key is ignored
Query is cached

Explanation: MongoDB performs a collection scan when no index is used.

Question 3: Which metric best indicates inefficient queries?

Documents returned
Execution time only
Keys examined vs documents examined
Index size

Explanation: A large gap indicates inefficient index usage.

Question 4: Why is a high-cardinality shard key preferred?

Improves read preference
Reduces memory usage
Ensures even data distribution
Speeds up indexing

Explanation: High cardinality prevents hotspot shards.

Question 5: What is the main risk of choosing a monotonically increasing shard key?

Duplicate keys
Write hotspots
Query inconsistency
Index corruption

Explanation: Sequential keys route writes to a single shard.

Question 6: Which aggregation stage should be placed as early as possible for performance?

$group
$project
$match
$lookup

Explanation: $match early reduces documents flowing through the pipeline.

Question 7: What does a blocking stage in aggregation mean?

Stage stops execution
Stage requires all input before output
Stage blocks indexing
Stage blocks writes

Explanation: Blocking stages need all data before producing results.

Question 8: Which aggregation stage is considered blocking?

$match
$limit
$group
$project

Explanation: $group must see all input documents.

Question 9: Why can $lookup impact performance heavily?

It disables indexes
It performs join-like operations
It blocks replication
It forces sharding

Explanation: $lookup joins data across collections.

Question 10: What is a covered query in MongoDB?

Query using aggregation
Query using shard key only
Query satisfied entirely by index
Query cached in memory

Explanation: Covered queries avoid reading documents.

Question 11: Why should large arrays be avoided in documents?

They break schema validation
They increase document size growth risk
They prevent indexing
They reduce consistency

Explanation: Unbounded arrays can exceed the 16MB limit.

Question 12: Which limit applies to a single MongoDB document?

8MB
10MB
12MB
16MB

Explanation: MongoDB documents are limited to 16MB.

Question 13: What is the main advantage of embedding over referencing?

Smaller documents
Faster reads
Better normalization
Lower memory usage

Explanation: Embedding avoids additional queries.

Question 14: When is referencing preferred over embedding?

One-to-many relationships
High update frequency and large datasets
Small static datasets
Read-heavy workloads

Explanation: Referencing avoids document growth issues.

Question 15: What does write concern 'majority' guarantee?

Fastest writes
Write acknowledged by majority of nodes
Write stored on disk
Write replicated to all shards

Explanation: Majority ensures replication to most nodes.

Question 16: Which setting ensures writes survive primary failure?

w:1
j:false
majority write concern
readPreference

Explanation: Majority ensures durability across replicas.

Question 17: Why are multi-document transactions slower?

They disable indexes
They lock the entire database
They add coordination overhead
They require sharding

Explanation: Transactions coordinate across multiple documents.

Question 18: Which MongoDB version introduced multi-document transactions?

Explanation: Transactions were introduced in MongoDB 4.0.

Question 19: Which isolation level does MongoDB transactions provide?

Serializable
Snapshot isolation
Read uncommitted
Repeatable read

Explanation: MongoDB provides snapshot isolation.

Question 20: What happens during a primary election?

Indexes are rebuilt
Clients reconnect
A new primary is chosen
Data is rebalanced

Explanation: Replica set elects a new primary.

Question 21: Why should applications handle retryable writes?

To avoid duplicates
To reduce latency
To handle transient failures
To improve indexing

Explanation: Retries handle network or failover issues.

Question 22: Which scenario can cause split-brain without safeguards?

Missing arbiter
Network partition
High latency
Large oplog

Explanation: Network partitions can isolate primaries.

Question 23: What role does the oplog play?

Query caching
Transaction storage
Replication synchronization
Index management

Explanation: Oplog records operations for replication.

Question 24: What happens if the oplog is too small?

Writes slow down
Secondaries fall behind
Indexes fail
Transactions break

Explanation: Secondaries may need full resync.

Question 25: Which operation benefits most from a hashed shard key?

Range queries
Sequential inserts
Even write distribution
Aggregation pipelines

Explanation: Hashed keys distribute writes evenly.

Question 26: Why are range queries inefficient with hashed shard keys?

Indexes are disabled
Queries scatter across shards
Documents are duplicated
Reads are blocked

Explanation: Ranges cannot target specific shards.

Question 27: Which MongoDB feature enables point-in-time recovery?

Snapshots
Oplog backup
Indexes
Replication only

Explanation: Oplog allows replaying operations.

Question 28: Which tool is best for real-time performance monitoring?

mongodump
mongoexport
mongostat
mongorestore

Explanation: mongostat shows live metrics.

Question 29: What does excessive index usage increase most?

Query latency
Write amplification
Read consistency
Shard imbalance

Explanation: Each write updates multiple indexes.

Question 30: Why should TTL indexes be used carefully?

They block writes
They delete data automatically
They slow queries
They disable replication

Explanation: TTL indexes permanently remove data.

Question 31: Which scenario best fits TTL indexes?

Audit logs
Session expiration
Financial records
User profiles

Explanation: TTL works well for expiring sessions.

Question 32: Why is $where discouraged?

Deprecated syntax
Uses JavaScript execution
Requires full index scan
Blocks writes

Explanation: $where executes JavaScript and is slow.

Question 33: Which MongoDB feature helps enforce data shape without joins?

Indexes
Schema validation
Transactions
Replication

Explanation: Schema validation enforces structure.

Question 34: What is the main benefit of partial indexes?

Smaller index size
Faster writes always
Automatic sharding
Better replication

Explanation: Partial indexes index only matching documents.

Question 35: Which condition benefits most from partial indexes?

Low selectivity queries
High cardinality fields
Queries on subset of documents
Full collection scans

Explanation: Partial indexes target specific subsets.

Question 36: Why should read preference 'secondary' be used cautiously?

Higher latency
Stale data risk
Index mismatch
Limited scalability

Explanation: Secondaries may lag behind primary.

Question 37: Which failure does journaling primarily protect against?

Network partition
Disk corruption
Process crash
Index loss

Explanation: Journaling helps recover after crashes.

Question 38: Which feature ensures atomicity at document level?

Transactions
Indexes
Document-level atomic operations
Write concern

Explanation: Single-document updates are atomic.

Question 39: Why are long-running transactions discouraged?

Memory overhead
Lock contention and resource usage
Index rebuilds
Replication failure

Explanation: They hold resources for too long.

Question 40: Which metric indicates replication lag?

opcounters
network bytes
oplog window
connections

Explanation: Oplog window shows replication delay.

Question 41: What is the main goal of MongoDB architecture?

Strong joins
Horizontal scalability
Strict schemas
Complex transactions

Explanation: MongoDB is designed for horizontal scale.

Question 42: Which practice best prepares MongoDB for production?

Disabling indexes
Monitoring and capacity planning
Using defaults only
Single-node deployment

Explanation: Monitoring ensures reliability at scale.

Question 43: Which risk increases with unbounded array growth?

Read inconsistency
Document size overflow
Index corruption
Transaction failure

Explanation: Documents may exceed size limits.

Question 44: Why is horizontal scaling a core MongoDB strength?

Lower memory usage
Automatic schema design
Built-in sharding support
Faster transactions

Explanation: MongoDB supports native sharding.

Question 45: What is the ultimate trade-off when using MongoDB at scale?

Performance vs availability
Consistency vs flexibility
Schema vs indexing
Speed vs security

Explanation: MongoDB trades strict consistency for flexibility and scale.

Back to programming Quizzes

MongoDB Quiz ( Advance )

Questions

Minutes

Min Limit