C100DEV Data Modeling Practice Question
When modeling with MongoDB, why should you avoid 'unbounded' growth in an array field?
⚠ Common exam trap
Students often assume arrays can grow indefinitely like lists in traditional programming languages, ignoring MongoDB's rigid physical document size constraints.
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
✓
Because it can lead to hitting the 16MB document limit.
Unbounded arrays are a dangerous anti-pattern because every document has a hard 16MB size limit. As an array grows, the document size increases, eventually causing write operations to fail. Furthermore, updating large documents forces the database to relocate the entire object on disk, which creates significant performance overhead. By limiting array growth, you ensure the database remains stable, performant, and within the physical constraints of the BSON format for all future operations.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Because it makes the JSON syntax harder to read.
Why it's wrong here
Code readability is a secondary concern compared to database performance and stability. While large arrays can make JSON responses longer, the primary reason to avoid them is the hard 16MB BSON limit and the performance penalty incurred when MongoDB needs to relocate large documents during update operations on disk.
- ✓
Because it can lead to hitting the 16MB document limit.
Why this is correct
The 16MB limit is a hard physical constraint for every BSON document. Unbounded arrays will eventually exceed this limit, causing the database to reject further writes for those documents. This leads to critical application failures that can only be resolved by refactoring the schema to use a different pattern.
- ✗
Because it prevents the use of secondary indexes.
Why it's wrong here
You can absolutely index arrays in MongoDB using multikey indexes. The problem with unbounded arrays is not the indexability, but the physical document size and the I/O cost associated with moving large documents during updates, which degrades performance regardless of whether you have secondary indexes defined on those fields.
- ✗
Because MongoDB does not support arrays as a data type.
Why it's wrong here
MongoDB fully supports arrays as a BSON data type. The issue is not the lack of support, but rather the management of document size. Using arrays is a common and powerful practice in MongoDB, provided that the number of elements remains bounded to prevent document bloat and performance degradation issues.
About these practice questions
Courseiva writes every C100DEV question from scratch — 259 in total, each with an explanation and a wrong-answer breakdown. None are copied from real exams or dumps. 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.