← GCDL·Google Cloud

Question 263 of 507

Fundamental cloud concepts →hardMultiple SelectObjective-mapped

Quick Answer

The answer is that an architect chooses two different database types to implement polyglot persistence, using multiple database types in one application to match each data pattern with the optimal storage engine. This is correct because relational databases enforce ACID properties—Atomicity, Consistency, Isolation, Durability—which are essential for transactional data like orders and payments, ensuring data integrity and compliance. Meanwhile, NoSQL databases offer high throughput and flexible schemas, making them ideal for user session data and product catalogs that require fast lookups and can tolerate eventual consistency. On the Google Cloud Digital Leader exam, this scenario tests your understanding of how cloud architects balance regulatory requirements, such as mandating separation of financial data from operational data, with performance needs. A common trap is assuming one database type fits all workloads; instead, remember that polyglot persistence is about choosing the right tool for each job. Memory tip: think “ACID for money, NoSQL for speed.”

Cloud Digital Leader Fundamental cloud concepts Practice Question

This GCDL practice question tests your understanding of fundamental cloud concepts. Read the scenario carefully and evaluate each option against the stated constraints before committing to an answer. After answering, compare your reasoning against the explanation and wrong-answer breakdown below. Once you have made your selection, read the full explanation to reinforce the concept and understand why each distractor is designed to mislead on exam day.

A company's application uses a relational database for transactional data (orders, payments) and a separate NoSQL database for user session data and product catalog. Why might an architect choose two different database types for the same application?

Question 1hardmulti select

Full question →

A
Using two databases reduces costs by splitting storage between cheaper providers.
Why wrong: Cost reduction is not the rationale. Polyglot persistence chooses the optimal database type for each data access pattern — the appropriate tool for the job, which may actually cost more due to running two services.
B
Different data patterns suit different database types — relational databases for ACID-compliant transactions, NoSQL for high-throughput flexible-schema lookups. This is called polyglot persistence.
Relational DBs (ACID, SQL, joins) handle orders/payments. NoSQL (flexible schema, horizontal scale, key-value) handles sessions and catalog. Using the right database type per workload is polyglot persistence.
C
Two databases provide automatic redundancy — if one fails, the other takes over.
Why wrong: Two different databases serving different workloads don't provide failover for each other. Redundancy is handled within each database service independently.
D
Regulatory requirements mandate separating financial data from operational data in different databases.
Data separation requirements exist for some compliance frameworks, but the described choice is about performance optimization (right tool for the workload), not regulatory compliance.

Full breakdown with real-world context →

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

✓

Different data patterns suit different database types — relational databases for ACID-compliant transactions, NoSQL for high-throughput flexible-schema lookups. This is called polyglot persistence.

Option B is correct because it describes polyglot persistence, where an application uses multiple database types to handle different data patterns optimally. Relational databases enforce ACID properties (Atomicity, Consistency, Isolation, Durability) essential for transactional data like orders and payments, ensuring data integrity. NoSQL databases, such as document stores or key-value stores, provide high throughput and flexible schemas ideal for session data and product catalogs, which require fast lookups and can tolerate eventual consistency.

Key principle: Answer the scenario, not the keyword: identify the specific constraint before choosing the most familiar-sounding option.

Answer analysis

Option-by-option breakdown

For each option: why learners choose it and why it is or isn't the right answer here.

✗
Using two databases reduces costs by splitting storage between cheaper providers.
Why it's wrong here
Cost reduction is not the rationale. Polyglot persistence chooses the optimal database type for each data access pattern — the appropriate tool for the job, which may actually cost more due to running two services.
✓
Different data patterns suit different database types — relational databases for ACID-compliant transactions, NoSQL for high-throughput flexible-schema lookups. This is called polyglot persistence.
Why this is correct
Relational DBs (ACID, SQL, joins) handle orders/payments. NoSQL (flexible schema, horizontal scale, key-value) handles sessions and catalog. Using the right database type per workload is polyglot persistence.
Related concept
Read the scenario before looking for a memorised answer.
✗
Two databases provide automatic redundancy — if one fails, the other takes over.
Why it's wrong here
Two different databases serving different workloads don't provide failover for each other. Redundancy is handled within each database service independently.
✓
Regulatory requirements mandate separating financial data from operational data in different databases.
Why this is correct
Data separation requirements exist for some compliance frameworks, but the described choice is about performance optimization (right tool for the workload), not regulatory compliance.
Related concept
Read the scenario before looking for a memorised answer.

Common exam traps

Common exam trap: answer the scenario, not the keyword

The trap here is that candidates confuse using multiple databases for redundancy (Option C) with polyglot persistence, but redundancy requires identical database systems with replication, not different types that cannot interoperate for failover.

Detailed technical explanation

How to think about this question

Polyglot persistence leverages the CAP theorem: relational databases prioritize Consistency and Partition tolerance (CP), while many NoSQL systems prioritize Availability and Partition tolerance (AP) with eventual consistency. For example, a product catalog in MongoDB can use a denormalized document model to avoid joins, reducing latency for read-heavy workloads, while PostgreSQL for orders uses serializable isolation to prevent phantom reads. In a real-world scenario, an e-commerce platform might use Cassandra for session data to handle millions of concurrent writes, but rely on MySQL for payment transactions to ensure atomic debits and credits.

KKey Concepts to Remember

Read the scenario before looking for a memorised answer.
Find the constraint that changes the correct option.
Eliminate answers that are true in general but not in this case.

TExam Day Tips

Watch for words such as best, first, most likely and least administrative effort.
Review why wrong options are wrong, not only why the correct option is correct.

Key takeaway

Answer the scenario, not the keyword: identify the specific constraint before choosing the most familiar-sounding option.

Real-world example

How this comes up in practice

A startup's cloud architect reviews their monthly bill and notices costs are higher than expected for a long-running batch job. Switching from on-demand instances to Reserved Instances — or using Spot/Preemptible VMs — can reduce compute costs by up to 72 %. Questions like this test whether you understand the tradeoffs between commitment, flexibility, and cost across cloud pricing models.

What to study next

Got this wrong? Here's your next step.

Identify which exam domain this question belongs to, review the core concept, then practise similar questions from the same domain.

Related GCDL practice-question pages

Use these pages to review the topic behind this question. This is how one missed question becomes focused revision.

Why cloud technology is transforming business practice questions

Practise GCDL questions linked to Why cloud technology is transforming business.

Fundamental cloud concepts practice questions

Practise GCDL questions linked to Fundamental cloud concepts.

Google Cloud products, services, and solutions practice questions

Practise GCDL questions linked to Google Cloud products, services, and solutions.

Scaling with Google Cloud operations practice questions

Practise GCDL questions linked to Scaling with Google Cloud operations.

Trust and security with Google Cloud practice questions

Practise GCDL questions linked to Trust and security with Google Cloud.

GCDL fundamentals practice questions

Practise GCDL questions linked to GCDL fundamentals.

GCDL scenario practice questions

Practise GCDL questions linked to GCDL scenario.

GCDL troubleshooting practice questions

Practise GCDL questions linked to GCDL troubleshooting.

Practice this exam

Start a free GCDL practice session

Short sessions build daily habit. Longer sessions build exam-day stamina. Try a timed session to simulate real conditions.

10 questions 20 questions 30 questions 50 questions Timed 30

GCDL practice-test guide →Study guide →Browse all practice tests

FAQ

Questions learners often ask

What does this GCDL question test?

Fundamental cloud concepts — This question tests Fundamental cloud concepts — Read the scenario before looking for a memorised answer..

What is the correct answer to this question?

The correct answer is: Different data patterns suit different database types — relational databases for ACID-compliant transactions, NoSQL for high-throughput flexible-schema lookups. This is called polyglot persistence. — Option B is correct because it describes polyglot persistence, where an application uses multiple database types to handle different data patterns optimally. Relational databases enforce ACID properties (Atomicity, Consistency, Isolation, Durability) essential for transactional data like orders and payments, ensuring data integrity. NoSQL databases, such as document stores or key-value stores, provide high throughput and flexible schemas ideal for session data and product catalogs, which require fast lookups and can tolerate eventual consistency.

What should I do if I get this GCDL question wrong?

Identify which exam domain this question belongs to, review the core concept, then practise similar questions from the same domain.

What is the key concept behind this question?

Read the scenario before looking for a memorised answer.

About these practice questions

Courseiva creates original exam-style practice questions with explanations and wrong-answer analysis. It does not publish real exam questions, exam dumps, or protected exam content. Learn why practice questions differ from exam dumps →

How Courseiva writes practice questions · Editorial policy

Keep practising

Question Discussion

Share a tip, memory trick, or ask about the reasoning behind this question. Do not post real exam questions, leaked content, braindumps, or copyrighted exam material. Comments are moderated and may be removed without notice.

Loading comments…

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.