DP-900 Describe considerations for working with non-relational data on Azure Practice Test 8 — 15 Questions

Question 1

A global social media app uses Azure Cosmos DB (NoSQL API) to store user profile data. The app is read-heavy and requires the fastest possible read performance worldwide. The data is updated by users and eventual consistency is acceptable because immediate consistency is not critical for profile views. Which consistency level should they choose to minimize read latency?

Accepted Answer

Eventual. Eventual consistency offers the lowest read latency because it allows reads from any replica without waiting for confirmation that the data is the most recent version. Since the app is read-heavy and eventual consistency is acceptable, this consistency level minimizes latency by not requiring any synchronization or staleness bounds.

Answer

Strong

Answer

Bounded staleness

Answer

Session

Question 2

A company develops an IoT device registry that stores device metadata as JSON documents. Each device has a unique DeviceID, and the attributes vary per device type (e.g., sensors, actuators). The application requires low-latency reads by DeviceID and needs global distribution to support devices worldwide. Which Azure Cosmos DB API should they choose to natively support JSON documents with flexible schema?

Accepted Answer

Azure Cosmos DB SQL API. The Azure Cosmos DB SQL API (formerly DocumentDB) is the correct choice because it provides native support for storing and querying JSON documents with flexible schema, allowing each device document to have a unique DeviceID and varying attributes per device type. It offers low-latency reads by DeviceID via direct point reads using the partition key, and supports global distribution through multi-region writes and automatic replication, meeting the worldwide deployment requirement.

Answer

Azure Cosmos DB Table API

Answer

Azure Cosmos DB for MongoDB API

Answer

Azure Cosmos DB Gremlin API

Question 3

A global online gaming company needs a data store for player game session logs. Each log record has a SessionID (unique), PlayerID, GameID, StartTime, EndTime, and a JSON payload containing variable game state details. The company requires low-latency writes for millions of concurrent sessions and wants to query by PlayerID and time range. Schema flexibility is important because game state details change frequently. Which Azure data store should they choose?

Accepted Answer

Azure Cosmos DB with the NoSQL API. Azure Cosmos DB with the NoSQL API is the correct choice because it provides low-latency writes (single-digit milliseconds at the 99th percentile) for millions of concurrent sessions, supports schema-flexible JSON documents that can accommodate frequently changing game state payloads, and enables efficient queries by PlayerID and time range using a composite index or a partition key like PlayerID combined with a time-based sort order.

Answer

Azure Table Storage

Answer

Azure Blob Storage

Answer

Azure SQL Database

Question 4

A manufacturing company collects sensor data from thousands of IoT devices. Each sensor reading includes a timestamp, device ID, and a variable set of measurements (e.g., temperature, pressure, vibration) that differ by device type. The company needs to store this data in a globally distributed NoSQL database that supports low-latency writes and flexible schema. Which Azure data store should they choose?

Accepted Answer

Azure Cosmos DB with the NoSQL API. Azure Cosmos DB with the NoSQL API is the correct choice because it is a globally distributed, multi-model database service that supports low-latency writes at scale, a flexible schema (schemaless), and automatic indexing of variable sensor measurements. Its multi-region write capability and configurable consistency levels meet the requirements of high-throughput IoT ingestion from thousands of devices.

Answer

Azure SQL Database

Answer

Azure Cache for Redis

Answer

Azure Database for PostgreSQL

Question 5

A mobile gaming company stores player session data as key-value pairs. Each player has a unique PlayerID, and the application needs to read/write the player's current level and score with very low latency. The data does not require complex queries, and the schema (attributes per player) can vary. The company wants a fully managed, globally distributed NoSQL database. Which Azure data store should they choose?

Accepted Answer

Azure Cosmos DB Table API. Azure Cosmos DB Table API is the correct choice because it provides a fully managed, globally distributed NoSQL database that supports key-value data with schema flexibility. It offers low-latency reads and writes (single-digit milliseconds at the 99th percentile) and automatic global distribution, making it ideal for storing player session data with varying attributes per player.

Answer

Azure SQL Database

Answer

Azure Blob Storage

Answer

Azure Cache for Redis

Question 6

A mobile app stores user preferences in Azure Cosmos DB using the NoSQL API. The app frequently reads a single user's profile by user ID (the partition key). The development team wants the fastest possible read performance globally and is willing to accept that reads might not reflect the latest write immediately. Which consistency level should they choose to minimize read latency?

Accepted Answer

Eventual. Eventual consistency offers the lowest read latency because it allows reads to return data from any replica without waiting for confirmation that the write has been fully replicated. Since the app can tolerate stale reads (i.e., not reflecting the latest write immediately), Eventual consistency eliminates the synchronization overhead required by stronger models, making it the fastest choice for global read performance.

Answer

Strong

Answer

Bounded staleness

Answer

Session

Question 7

A company needs to store archived log files that are rarely accessed but must be retained for regulatory compliance. The logs are text-based and each file is about 10 MB. They want the lowest storage cost while ensuring the data is durable and can be read when needed. Which Azure Blob Storage access tier should they choose?

Accepted Answer

Archive. The Archive tier is the correct choice because it offers the lowest storage cost for data that is rarely accessed and must be retained for long periods. Archived log files that are text-based and 10 MB each fit this profile perfectly, as the Archive tier is designed for data that can tolerate a retrieval latency of several hours (up to 15 hours for standard priority) while providing the same high durability (99.9999999999% or 11 nines) as other tiers. The data remains fully durable and can be read when needed by first rehydrating it to an online tier (Hot, Cool, or Cold) before access.

Answer

Hot

Answer

Cool

Answer

Cold

Question 8

A global social media app uses Azure Cosmos DB (NoSQL API) to store user profile data. The app is read-heavy and must serve content with the lowest possible latency to users worldwide. The data is updated by users, and the business has determined that eventual consistency is acceptable because immediate consistency after a write is not critical for profile views. Which consistency level should they choose to minimize read latency?

Accepted Answer

Eventual. Eventual consistency is the correct choice because it offers the lowest read latency by allowing reads to return data immediately without waiting for replication to complete. Since the app is read-heavy, global, and can tolerate eventual consistency for profile views, this consistency level minimizes the time to serve content by not imposing any ordering or staleness guarantees on replicas.

Answer

Strong

Answer

Bounded staleness

Answer

Session

Question 9

A company stores user session data for a web application. Each session has a unique SessionID, UserID, start time, end time, and a variable set of attributes (e.g., pages visited, clicks, device type). The workload requires low-latency reads by SessionID and occasional queries by UserID and time range. Schema flexibility is critical because the attributes evolve over time. The team wants a fully managed NoSQL database that supports secondary indexing. Which Azure data store should they choose?

Accepted Answer

Azure Cosmos DB (NoSQL API). Azure Cosmos DB (NoSQL API) is correct because it is a fully managed NoSQL database that offers low-latency reads by SessionID (using a partition key), supports secondary indexing for queries by UserID and time range, and provides schema flexibility for evolving session attributes. Its multi-model API and global distribution meet the workload requirements without manual indexing or schema management.

Answer

Azure SQL Database

Answer

Azure Table Storage

Answer

Azure Blob Storage

Question 10

A mobile gaming company stores player activity logs as JSON documents. Each document has a unique ActivityID, a PlayerID, a timestamp, and a variable set of attributes depending on the game event (e.g., level started, item purchased). The application requires low-latency point reads by ActivityID and needs to query logs by PlayerID for a given time range. Schema flexibility is critical because new game events are added frequently. Which Azure Cosmos DB API should they choose?

Accepted Answer

NoSQL API (formerly SQL API). The NoSQL API (formerly SQL API) is the correct choice because it natively supports JSON documents with flexible schemas, enabling the variable attributes required for new game events. It provides low-latency point reads by ActivityID via direct partition key lookups and supports efficient queries by PlayerID within a time range using composite indexes or cross-partition queries with filtering. This API is optimized for schema-agnostic, document-based workloads and offers the richest query capabilities for JSON data in Azure Cosmos DB.

Answer

MongoDB API

Answer

Cassandra API

Answer

Gremlin API

Question 11

A smart building company stores sensor data from thousands of IoT devices as JSON documents in Azure Cosmos DB using the NoSQL API. Each document contains fields: deviceId (string), timestamp (datetime), temperature (float), humidity (float), and additional device-specific fields (e.g., motionDetected, CO2level). The most common query is: SELECT * FROM c WHERE c.deviceId = 'sensor-123' AND c.timestamp >= '2025-01-01' AND c.timestamp < '2025-02-01' ORDER BY c.timestamp DESC. Which indexing strategy will provide the best performance for this query?

Accepted Answer

Create a composite index on (deviceId ASC, timestamp DESC). Option B is correct because the query filters on `deviceId` (equality) and `timestamp` (range with ORDER BY DESC). A composite index on `(deviceId ASC, timestamp DESC)` allows Cosmos DB to efficiently locate the partition for the device and then scan the timestamp range in descending order without an in-memory sort, minimizing RU consumption and latency.

Answer

Use the default indexing policy that automatically indexes all properties

Answer

Disable indexing for all properties to speed up writes

Answer

Create a spatial index on the deviceId field

Question 12

A gaming company stores player profiles in Azure Cosmos DB using the NoSQL API. Each profile is a JSON document containing fields like playerId, userName, level, inventory (an array of items), and friends (an array of playerIds). The application frequently needs to query all players that have a specific item in their inventory (e.g., 'sword'). Which Cosmos DB feature should they use to support this query efficiently?

Accepted Answer

Indexing policy with a wildcard index. Option D is correct because a wildcard index in the indexing policy allows Azure Cosmos DB to automatically index all properties within a JSON document, including nested array elements like those in the 'inventory' array. This enables efficient queries such as 'SELECT * FROM c WHERE ARRAY_CONTAINS(c.inventory, {name: "sword"})' without requiring a custom composite index for each possible item. Without a wildcard index, the query would require a full scan of all documents, which is inefficient at scale.

Answer

Change feed

Answer

Stored procedures

Answer

Composite index

Question 13

A company stores IoT sensor data as JSON files in Azure Blob Storage. A data analyst needs to run ad-hoc SQL queries on these files without moving the data and without provisioning any compute clusters. The analyst wants to pay only for the amount of data processed by each query. Which Azure service should they use?

Accepted Answer

Azure Synapse Serverless SQL pool. Azure Synapse Serverless SQL pool allows you to query data directly from Azure Blob Storage using T-SQL without provisioning any compute clusters. It uses a pay-per-query model where you are billed only for the amount of data processed, making it ideal for ad-hoc SQL queries on JSON files stored in Blob Storage without data movement.

Answer

Azure SQL Database

Answer

Azure Cosmos DB

Answer

Azure Data Factory

Question 14

A mobile gaming startup needs to store player profiles that can have varying attributes (e.g., some players have a 'nickname', others have 'avatar URL'). The application must read a player's profile by PlayerID with very low latency (under 10 ms) from any location worldwide. The data does not require complex queries or joins. Which Azure data store should they choose?

Accepted Answer

Azure Cosmos DB. Azure Cosmos DB is the correct choice because it is a globally distributed, multi-model database service that guarantees single-digit-millisecond read latencies (under 10 ms) at any scale from any Azure region. Its schema-agnostic nature allows storing player profiles with varying attributes (e.g., nickname, avatar URL) without requiring a fixed schema, and it supports point reads by PlayerID with a consistency model that can be tuned for performance. This directly matches the requirements of low-latency global reads and flexible, non-relational data.

Answer

Azure SQL Database

Answer

Azure Table Storage

Answer

Azure Blob Storage

Question 15

A smart building company stores IoT sensor data in Azure Cosmos DB using the NoSQL API. Each document contains fields: deviceId (partition key), timestamp, temperature, and humidity. The most common query is to retrieve all readings for a specific device within a time range, which runs efficiently. However, the analytics team occasionally runs a query to find all devices that reported a temperature above 50 degrees Celsius in the last hour, without specifying deviceId. This query is very slow and consumes a high number of request units (RUs). What is the most likely reason for the slow performance and high RU consumption?

Accepted Answer

The query does not use the partition key, causing a cross-partition scan.. The query does not include the partition key (deviceId) in the filter, so Azure Cosmos DB cannot route it to a single physical partition. Instead, it must fan out the query to every partition, scanning all documents across the container. This cross-partition query consumes significantly more RUs and takes longer because each partition must be queried sequentially or in parallel, and the results are merged server-side.

Answer

The query is not using an index on the temperature field.

Answer

The time range filter is too large, causing a full table scan.

Answer

The document size is too large, increasing RU per read.