Pass Microsoft Azure Data DP-900 Exam in First Attempt Easily
Real Microsoft Azure Data DP-900 Exam Questions, Accurate & Verified Answers As Experienced in the Actual Test!

Verified by experts
3 products

You save $69.98

DP-900 Premium Bundle

  • Premium File 332 Questions & Answers
  • Last Update: Nov 14, 2026
  • Training Course 32 Lectures
  • Study Guide 672 Pages
$79.99 $149.97

Purchase Individually

  • Premium File

    332 Questions & Answers
    Last Update: Nov 14, 2026

    $76.99
    $69.99
  • Training Course

    32 Lectures

    $43.99
    $39.99
  • Study Guide

    672 Pages

    $43.99
    $39.99

Microsoft Azure Data Fundamentals DP-900 Practice Test 27

Question 260

A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. If the team ignores the targeted approach (Evaluate Azure Cosmos DB for Table while confirming supported behavior differences.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?

  1. Selecting the API for NoSQL without adapting the driver may break MongoDB wire-protocol expectations.
  2. Assuming every document has an identical set of relational columns undermines the flexible schema requirement.
  3. Polling full containers for every change wastes requests and can increase detection delay.
  4. A native NoSQL API is not a drop-in Table API without adapting clients.

Explanation

Correct Answer

D:

A native NoSQL API is not a drop-in Table API without adapting clients. This risk follows from the exact scenario: A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. The reason is cosmos DB for Table provides Table-compatible entity operations with added distribution capabilities. The direct mitigation is: Evaluate Azure Cosmos DB for Table while confirming supported behavior differences.

Incorrect Answers

A:

Selecting the API for NoSQL without adapting the driver may break MongoDB wire-protocol expectations. This is a real potential problem in a different scenario: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. The present case instead concerns A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. With the targeted action omitted, the direct exposure is A native NoSQL API is not a drop-in Table API without adapting clients.

B:

Assuming every document has an identical set of relational columns undermines the flexible schema requirement. This is a real potential problem in a different scenario: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The present case instead concerns A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. With the targeted action omitted, the direct exposure is A native NoSQL API is not a drop-in Table API without adapting clients.

C:

Polling full containers for every change wastes requests and can increase detection delay. This is a real potential problem in a different scenario: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. The present case instead concerns A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. With the targeted action omitted, the direct exposure is A native NoSQL API is not a drop-in Table API without adapting clients.

Question 261

An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?

  1. Use Azure Cosmos DB for NoSQL with an appropriate partition key.
  2. Design a partition key that distributes request traffic and aligns with frequent queries.
  3. Evaluate Azure Cosmos DB for Table while confirming supported behavior differences.
  4. Consider Azure Cosmos DB API for Apache Cassandra with verified CQL compatibility.

Explanation

Correct Answer

B:

Design a partition key that distributes request traffic and aligns with frequent queries. This directly addresses the case: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. The deciding technical reason is that cosmos DB partition keys shape data placement and request distribution. Verify the solution by checking: Requests distribute across relevant logical partitions without a single hot tenant key.

Incorrect Answers

A:

Use Azure Cosmos DB for NoSQL with an appropriate partition key. This is a legitimate approach for a different problem: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. Cosmos DB for NoSQL stores JSON items in partitioned containers. It does not directly satisfy the present constraint: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. The needed outcome is: Requests distribute across relevant logical partitions without a single hot tenant key.

C:

Evaluate Azure Cosmos DB for Table while confirming supported behavior differences. This is a legitimate approach for a different problem: A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. Cosmos DB for Table provides Table-compatible entity operations with added distribution capabilities. It does not directly satisfy the present constraint: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. The needed outcome is: Requests distribute across relevant logical partitions without a single hot tenant key.

D:

Consider Azure Cosmos DB API for Apache Cassandra with verified CQL compatibility. This is a legitimate approach for a different problem: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The Cassandra API provides compatibility for Cassandra-style wide-column clients. It does not directly satisfy the present constraint: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. The needed outcome is: Requests distribute across relevant logical partitions without a single hot tenant key.

Question 262

An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. A team proposes: Design a partition key that distributes request traffic and aligns with frequent queries. Which observation would BEST demonstrate that this exact requirement was met?

  1. Cart documents with optional properties are read by the app at the designed global scale.
  2. The Azure Tables SDK accesses the migrated key/attribute records using its intended account type.
  3. Requests distribute across relevant logical partitions without a single hot tenant key.
  4. The CQL client reads and writes data using supported Cassandra operations.

Explanation

Correct Answer

C:

Requests distribute across relevant logical partitions without a single hot tenant key. Cosmos DB partition keys shape data placement and request distribution. It is tied to this case: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions.

Incorrect Answers

A:

Cart documents with optional properties are read by the app at the designed global scale. This would validate a different scenario: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The proposed change here is Design a partition key that distributes request traffic and aligns with frequent queries. and its decisive acceptance check is Requests distribute across relevant logical partitions without a single hot tenant key.

B:

The Azure Tables SDK accesses the migrated key/attribute records using its intended account type. This would validate a different scenario: A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. The proposed change here is Design a partition key that distributes request traffic and aligns with frequent queries. and its decisive acceptance check is Requests distribute across relevant logical partitions without a single hot tenant key.

D:

The CQL client reads and writes data using supported Cassandra operations. This would validate a different scenario: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The proposed change here is Design a partition key that distributes request traffic and aligns with frequent queries. and its decisive acceptance check is Requests distribute across relevant logical partitions without a single hot tenant key.

Question 263

During an architecture review, the team proposes: Design a partition key that distributes request traffic and aligns with frequent queries. The requirement is: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. Which technical explanation BEST justifies this specific recommendation?

  1. Cosmos DB for NoSQL stores JSON items in partitioned containers.
  2. Cosmos DB for Table provides Table-compatible entity operations with added distribution capabilities.
  3. The Cassandra API provides compatibility for Cassandra-style wide-column clients.
  4. Cosmos DB partition keys shape data placement and request distribution.

Explanation

Correct Answer

D:

Cosmos DB partition keys shape data placement and request distribution. Evidence would be: Requests distribute across relevant logical partitions without a single hot tenant key. The choice avoids this risk: A constant partition key can create a hot partition and constrain scaling.

Incorrect Answers

A:

Cosmos DB for NoSQL stores JSON items in partitioned containers. That principle applies to the separate requirement: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. It may be true in that setting, but does not specifically explain why Design a partition key that distributes request traffic and aligns with frequent queries. is the best fit here. The relevant reason is Cosmos DB partition keys shape data placement and request distribution.

B:

Cosmos DB for Table provides Table-compatible entity operations with added distribution capabilities. That principle applies to the separate requirement: A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. It may be true in that setting, but does not specifically explain why Design a partition key that distributes request traffic and aligns with frequent queries. is the best fit here. The relevant reason is Cosmos DB partition keys shape data placement and request distribution.

C:

The Cassandra API provides compatibility for Cassandra-style wide-column clients. That principle applies to the separate requirement: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. It may be true in that setting, but does not specifically explain why Design a partition key that distributes request traffic and aligns with frequent queries. is the best fit here. The relevant reason is Cosmos DB partition keys shape data placement and request distribution.

Question 264

An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. If the team ignores the targeted approach (Design a partition key that distributes request traffic and aligns with frequent queries.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?

  1. A constant partition key can create a hot partition and constrain scaling.
  2. Assuming every document has an identical set of relational columns undermines the flexible schema requirement.
  3. A native NoSQL API is not a drop-in Table API without adapting clients.
  4. A MongoDB interface does not automatically accept Cassandra Query Language.

Explanation

Correct Answer

A:

A constant partition key can create a hot partition and constrain scaling. This risk follows from the exact scenario: An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. The reason is cosmos DB partition keys shape data placement and request distribution. The direct mitigation is: Design a partition key that distributes request traffic and aligns with frequent queries.

Incorrect Answers

B:

Assuming every document has an identical set of relational columns undermines the flexible schema requirement. This is a real potential problem in a different scenario: A globally distributed app stores flexible JSON shopping carts and must scale without a fixed relational schema. The present case instead concerns An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. With the targeted action omitted, the direct exposure is A constant partition key can create a hot partition and constrain scaling.

C:

A native NoSQL API is not a drop-in Table API without adapting clients. This is a real potential problem in a different scenario: A customer currently uses Azure Table Storage SDK entities and wants global distribution with a familiar Table API. The present case instead concerns An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. With the targeted action omitted, the direct exposure is A constant partition key can create a hot partition and constrain scaling.

D:

A MongoDB interface does not automatically accept Cassandra Query Language. This is a real potential problem in a different scenario: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The present case instead concerns An event application places every device event into one Cosmos DB logical partition despite heavy ingestion from many regions. With the targeted action omitted, the direct exposure is A constant partition key can create a hot partition and constrain scaling.

Question 265

A global booking application needs to balance consistent reads against latency and availability for distributed clients. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?

  1. Replicate the Cosmos DB account to selected regions and choose suitable read routing and consistency.
  2. Include the relevant partition key in targeted item lookups and review RU charges.
  3. Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement.
  4. Use the Cosmos DB change feed to consume relevant item changes.

Explanation

Correct Answer

C:

Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. This directly addresses the case: A global booking application needs to balance consistent reads against latency and availability for distributed clients. The deciding technical reason is that cosmos DB exposes configurable consistency models with differing guarantees. Verify the solution by checking: A read-consistency test demonstrates the permitted staleness and ordering behavior.

Incorrect Answers

A:

Replicate the Cosmos DB account to selected regions and choose suitable read routing and consistency. This is a legitimate approach for a different problem: An enterprise configures multiple Cosmos DB regions and needs low-latency reads near international users. Cosmos DB supports global distribution and configurable consistency across regions. It does not directly satisfy the present constraint: A global booking application needs to balance consistent reads against latency and availability for distributed clients. The needed outcome is: A read-consistency test demonstrates the permitted staleness and ordering behavior.

B:

Include the relevant partition key in targeted item lookups and review RU charges. This is a legitimate approach for a different problem: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. Cosmos DB request units measure throughput consumption; key-based access can be efficient. It does not directly satisfy the present constraint: A global booking application needs to balance consistent reads against latency and availability for distributed clients. The needed outcome is: A read-consistency test demonstrates the permitted staleness and ordering behavior.

D:

Use the Cosmos DB change feed to consume relevant item changes. This is a legitimate approach for a different problem: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. Change feed surfaces committed data changes to downstream processors. It does not directly satisfy the present constraint: A global booking application needs to balance consistent reads against latency and availability for distributed clients. The needed outcome is: A read-consistency test demonstrates the permitted staleness and ordering behavior.

Question 266

A global booking application needs to balance consistent reads against latency and availability for distributed clients. A team proposes: Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. Which observation would BEST demonstrate that this exact requirement was met?

  1. Readers in the configured regions use the designed replica path with documented consistency.
  2. A point read obtains the intended item with a smaller measurable request charge.
  3. A consumer receives new changes in order within the supported change-feed semantics.
  4. A read-consistency test demonstrates the permitted staleness and ordering behavior.

Explanation

Correct Answer

D:

A read-consistency test demonstrates the permitted staleness and ordering behavior. Cosmos DB exposes configurable consistency models with differing guarantees. It is tied to this case: A global booking application needs to balance consistent reads against latency and availability for distributed clients.

Incorrect Answers

A:

Readers in the configured regions use the designed replica path with documented consistency. This would validate a different scenario: An enterprise configures multiple Cosmos DB regions and needs low-latency reads near international users. The proposed change here is Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. and its decisive acceptance check is A read-consistency test demonstrates the permitted staleness and ordering behavior.

B:

A point read obtains the intended item with a smaller measurable request charge. This would validate a different scenario: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. The proposed change here is Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. and its decisive acceptance check is A read-consistency test demonstrates the permitted staleness and ordering behavior.

C:

A consumer receives new changes in order within the supported change-feed semantics. This would validate a different scenario: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. The proposed change here is Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. and its decisive acceptance check is A read-consistency test demonstrates the permitted staleness and ordering behavior.

Question 267

During an architecture review, the team proposes: Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. The requirement is: A global booking application needs to balance consistent reads against latency and availability for distributed clients. Which technical explanation BEST justifies this specific recommendation?

  1. Cosmos DB exposes configurable consistency models with differing guarantees.
  2. Cosmos DB supports global distribution and configurable consistency across regions.
  3. Cosmos DB request units measure throughput consumption; key-based access can be efficient.
  4. Change feed surfaces committed data changes to downstream processors.

Explanation

Correct Answer

A:

Cosmos DB exposes configurable consistency models with differing guarantees. Evidence would be: A read-consistency test demonstrates the permitted staleness and ordering behavior. The choice avoids this risk: Assuming all consistency levels provide identical latency and guarantees can break business expectations.

Incorrect Answers

B:

Cosmos DB supports global distribution and configurable consistency across regions. That principle applies to the separate requirement: An enterprise configures multiple Cosmos DB regions and needs low-latency reads near international users. It may be true in that setting, but does not specifically explain why Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. is the best fit here. The relevant reason is Cosmos DB exposes configurable consistency models with differing guarantees.

C:

Cosmos DB request units measure throughput consumption; key-based access can be efficient. That principle applies to the separate requirement: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. It may be true in that setting, but does not specifically explain why Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. is the best fit here. The relevant reason is Cosmos DB exposes configurable consistency models with differing guarantees.

D:

Change feed surfaces committed data changes to downstream processors. That principle applies to the separate requirement: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. It may be true in that setting, but does not specifically explain why Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement. is the best fit here. The relevant reason is Cosmos DB exposes configurable consistency models with differing guarantees.

Question 268

A global booking application needs to balance consistent reads against latency and availability for distributed clients. If the team ignores the targeted approach (Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?

  1. A single distant region cannot automatically provide the same regional data locality.
  2. Assuming all consistency levels provide identical latency and guarantees can break business expectations.
  3. Cross-partition scans use more resources when the partition and id are already known.
  4. Polling full containers for every change wastes requests and can increase detection delay.

Explanation

Correct Answer

B:

Assuming all consistency levels provide identical latency and guarantees can break business expectations. This risk follows from the exact scenario: A global booking application needs to balance consistent reads against latency and availability for distributed clients. The reason is cosmos DB exposes configurable consistency models with differing guarantees. The direct mitigation is: Choose a Cosmos DB consistency setting based on the actual correctness and latency requirement.

Incorrect Answers

A:

A single distant region cannot automatically provide the same regional data locality. This is a real potential problem in a different scenario: An enterprise configures multiple Cosmos DB regions and needs low-latency reads near international users. The present case instead concerns A global booking application needs to balance consistent reads against latency and availability for distributed clients. With the targeted action omitted, the direct exposure is Assuming all consistency levels provide identical latency and guarantees can break business expectations.

C:

Cross-partition scans use more resources when the partition and id are already known. This is a real potential problem in a different scenario: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. The present case instead concerns A global booking application needs to balance consistent reads against latency and availability for distributed clients. With the targeted action omitted, the direct exposure is Assuming all consistency levels provide identical latency and guarantees can break business expectations.

D:

Polling full containers for every change wastes requests and can increase detection delay. This is a real potential problem in a different scenario: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. The present case instead concerns A global booking application needs to balance consistent reads against latency and availability for distributed clients. With the targeted action omitted, the direct exposure is Assuming all consistency levels provide identical latency and guarantees can break business expectations.

Question 269

A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?

  1. Include the relevant partition key in targeted item lookups and review RU charges.
  2. Choose the Azure Cosmos DB API for MongoDB option compatible with the application.
  3. Consider Azure Cosmos DB API for Apache Cassandra with verified CQL compatibility.
  4. Use the Cosmos DB change feed to consume relevant item changes.

Explanation

Correct Answer

D:

Use the Cosmos DB change feed to consume relevant item changes. This directly addresses the case: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. The deciding technical reason is that change feed surfaces committed data changes to downstream processors. Verify the solution by checking: A consumer receives new changes in order within the supported change-feed semantics.

Incorrect Answers

A:

Include the relevant partition key in targeted item lookups and review RU charges. This is a legitimate approach for a different problem: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. Cosmos DB request units measure throughput consumption; key-based access can be efficient. It does not directly satisfy the present constraint: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. The needed outcome is: A consumer receives new changes in order within the supported change-feed semantics.

B:

Choose the Azure Cosmos DB API for MongoDB option compatible with the application. This is a legitimate approach for a different problem: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. Cosmos DB for MongoDB exposes MongoDB-compatible interfaces. It does not directly satisfy the present constraint: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. The needed outcome is: A consumer receives new changes in order within the supported change-feed semantics.

C:

Consider Azure Cosmos DB API for Apache Cassandra with verified CQL compatibility. This is a legitimate approach for a different problem: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The Cassandra API provides compatibility for Cassandra-style wide-column clients. It does not directly satisfy the present constraint: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. The needed outcome is: A consumer receives new changes in order within the supported change-feed semantics.

Question 270

A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document. A team proposes: Use the Cosmos DB change feed to consume relevant item changes. Which observation would BEST demonstrate that this exact requirement was met?

  1. A consumer receives new changes in order within the supported change-feed semantics.
  2. A point read obtains the intended item with a smaller measurable request charge.
  3. Existing MongoDB client operations function under the tested protocol compatibility subset.
  4. The CQL client reads and writes data using supported Cassandra operations.

Explanation

Correct Answer

A:

A consumer receives new changes in order within the supported change-feed semantics. Change feed surfaces committed data changes to downstream processors. It is tied to this case: A service must respond to inserted and updated Cosmos DB items without repeatedly scanning every stored document.

Incorrect Answers

B:

A point read obtains the intended item with a smaller measurable request charge. This would validate a different scenario: A distributed service sees unusually costly Cosmos DB queries that scan every customer partition despite always knowing CustomerId. The proposed change here is Use the Cosmos DB change feed to consume relevant item changes. and its decisive acceptance check is A consumer receives new changes in order within the supported change-feed semantics.

C:

Existing MongoDB client operations function under the tested protocol compatibility subset. This would validate a different scenario: An existing application uses MongoDB drivers and query syntax and needs a compatible managed Azure service. The proposed change here is Use the Cosmos DB change feed to consume relevant item changes. and its decisive acceptance check is A consumer receives new changes in order within the supported change-feed semantics.

D:

The CQL client reads and writes data using supported Cassandra operations. This would validate a different scenario: A legacy wide-column application uses Cassandra Query Language and needs a compatible globally distributed cloud endpoint. The proposed change here is Use the Cosmos DB change feed to consume relevant item changes. and its decisive acceptance check is A consumer receives new changes in order within the supported change-feed semantics.

Microsoft Azure Data Fundamentals (DP-900) Practice Tests

Purchase Individually

  • Premium File

    332 Questions & Answers
    Last Update: Nov 14, 2026

    $76.99
    $69.99
  • Training Course

    32 Lectures

    $43.99
    $39.99
  • Study Guide

    672 Pages

    $43.99
    $39.99

SPECIAL OFFER: GET 10% OFF
This is ONE TIME OFFER

You save
10%

Enter Your Email Address to Receive Your 10% Off Discount Code

SPECIAL OFFER: GET 10% OFF

You save
10%

Use Discount Code:

A confirmation link was sent to your e-mail.

Please check your mailbox for a message from support@examlabs.com and follow the directions.

Download Free Demo of VCE Exam Simulator

Experience Avanset VCE Exam Simulator for yourself.

Simply submit your email address below to get started with our interactive software demo of your free trial.

  • Realistic exam simulation and exam editor with preview functions
  • Whole exam in a single file with several different question types
  • Customizable exam-taking mode & detailed score reports