hardMultiple ChoiceObjective-mapped
Cloud Digital Leader Practice Question: An architect is evaluating whether to use a…
An architect is evaluating whether to use a relational database or a NoSQL database for a new application that must store product catalog data. Products have highly variable attributes — a book has ISBN, author, and genre; a bicycle has frame size, wheel diameter, and material. Which database characteristic makes NoSQL document databases advantageous for this use case?
⚠ Common exam trap
Google Cloud often tests the misconception that NoSQL is always faster or simpler than SQL, but the real advantage here is schema flexibility, not performance or ease of querying.
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
✓
NoSQL document databases support flexible schemas where each document can have different fields — making them well-suited for product catalogs where different product types have different attributes
NoSQL document databases, such as MongoDB, store data in flexible, schema-less documents (often JSON or BSON). This allows each document to have a different set of fields, making them ideal for product catalogs where a book and a bicycle have entirely different attributes (e.g., ISBN vs. frame size). Relational databases require a predefined schema with fixed columns, forcing you to either create many sparse columns or use complex join tables to handle variable attributes.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
NoSQL databases always provide faster query performance than relational databases for all use cases
Why it's wrong here
This is a misconception because performance depends on the query access pattern and storage engine. NoSQL systems like DynamoDB or Cassandra excel at key-value lookups and simple document retrieval through consistent hashing and distributed indexing, but they lack sophisticated query optimizers and join capabilities that relational engines (e.g., PostgreSQL, SQL Server) have. For complex analytical queries, aggregations, or multi-table joins, a well-tuned relational database with columnar indexes can outperform a document store. Therefore, NoSQL is not universally faster; its speed advantage applies only to specific workloads that match its data model and sharding strategy.
- ✓
NoSQL document databases support flexible schemas where each document can have different fields — making them well-suited for product catalogs where different product types have different attributes
Why this is correct
Schema flexibility is the key advantage here. In a relational table, all rows share the same columns — a shared schema requires either many NULL columns (one per possible attribute across all product types) or complex entity-attribute-value designs. Document databases store each product as a flexible JSON document, accommodating variable attributes naturally without schema changes.
- ✗
NoSQL databases support ACID transactions better than relational databases, making them safer for product catalog updates
Why it's wrong here
This is incorrect because most NoSQL databases are designed around the CAP theorem, favoring availability and partition tolerance over strict consistency, whereas relational databases have mature, full-strength ACID transactions. For instance, a product catalog update that modifies a product and its inventory count across multiple documents may require the document store to support multi-document transactions (which are not always available or have performance costs), while a relational database like MySQL or PostgreSQL easily guarantees atomicity, consistency, isolation, and durability. Even modern NoSQL systems like Google Spanner or Firestore do support transactions, but they are the exception and such support is not the core advantage of NoSQL. For transactional integrity in a multi-item product catalog, relational databases are generally safer.
- ✗
NoSQL databases are simpler to query because they don't require learning SQL
Why it's wrong here
NoSQL query languages and APIs have their own learning curves. Some argue they're harder to query than SQL for complex filtering and aggregation. Query language simplicity is not the differentiating advantage for the product catalog use case.
Go deeper
Related to this question
Learn chapter
BigQuery and Data Analytics
Key term
SQL
SQL is a standardized programming language used to manage and manipulate relational databases, enabling querying, updating, and data retrieval.
Key term
Relational database
A relational database organizes data into tables with rows and columns, where each table relates to others using unique keys, allowing efficient storage, retrieval, and manipulation of structured information.
About these practice questions
This GCDL question is part of Courseiva's 829-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This GCDL practice question is part of Courseiva's free Google Cloud 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 GCDL exam.