C100DEV Drivers, Tools, Transactions, and Search Practice Question
An application uses a multi-document transaction to update inventory and process an order. What happens if the transaction exceeds the default transaction lifetime limit of 60 seconds?
⚠ Common exam trap
Students often believe transactions can run indefinitely as long as the client stays connected, ignoring the server-enforced lifetime timeout limit.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
The server automatically aborts the transaction and returns an error to the client.
Transactions in MongoDB are designed to be short-lived to prevent performance degradation and memory pressure. If a transaction stays open longer than the transactionLifetimeLimitSeconds configuration, the reaper process marks it as aborted. This ensures that locking contention is minimized, as prolonged transactions hold locks on documents, preventing other operations from proceeding and potentially leading to high latency or deadlocks across the cluster.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
The transaction automatically commits partial changes to ensure data availability.
Why it's wrong here
MongoDB transactions maintain atomicity through the all-or-nothing principle. Partial commits violate the ACID property of atomicity. If a transaction exceeds the lifetime limit, the server aborts the entire transaction, rolling back all pending changes to maintain a consistent state within the database cluster.
- ✗
The client receives a warning, but the transaction continues until completion.
Why it's wrong here
The transactionLifetimeLimitSeconds setting is a hard limit enforced by the server's background reaper process. Once the threshold is reached, the server forcefully terminates the transaction, regardless of the client's status or progress, to protect the cluster from resource exhaustion and long-held write locks.
- ✓
The server automatically aborts the transaction and returns an error to the client.
Why this is correct
When the transaction duration exceeds the configured limit, the server aborts it to prevent prolonged locking. The client receives an error upon the next attempt to interact with the transaction or during the commit phase, signaling that the operation failed and must be retried.
- ✗
The database increases the transaction lifetime limit dynamically to prevent failure.
Why it's wrong here
MongoDB does not dynamically adjust server-wide configuration parameters like transactionLifetimeLimitSeconds based on active transaction activity. Static limits are strictly enforced to ensure predictable system behavior and to prevent a single runaway transaction from consuming excessive server resources or blocking concurrent write operations indefinitely.
About these practice questions
One of 259 original C100DEV practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
JA
Written and reviewed by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
Last reviewed September 2026 · checked against the official MongoDB exam blueprint
This C100DEV practice question is part of Courseiva's free MongoDB certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the C100DEV exam.