Describe considerations for working with non-relational data on Azure →mediumMultiple ChoiceObjective-mapped
DP-900 Practice Question: Describe considerations for working with non-relational data on Azure
A manufacturing company collects sensor readings from thousands of IoT devices. Each reading consists of a device ID, a timestamp, and a numeric value. The data is stored as key-value pairs and must support low-latency reads and writes at a global scale. The company also needs to query the data by device ID and time range. Which Azure Cosmos DB API should they choose?
⚠ Common exam trap
Watch out — candidates often choose the Core (SQL) API because they associate SQL with querying, but the Table API is specifically built for key-value and time-series workloads with composite key queries, which is the exact pattern described.
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
✓
Table API
The Table API is the correct choice because it is designed for key-value workloads with a schema-less design, supporting low-latency reads and writes at global scale. It allows querying by partition key (device ID) and row key (timestamp) to efficiently retrieve data by device ID and time range, matching the IoT sensor data requirements.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Core (SQL) API
Why it's wrong here
The Core (SQL) API would store each sensor reading as a JSON document and support SQL-like queries, but it is not engineered for simple key-value point lookups. Every request in the Core API passes through a query engine and automatic indexing layer, which adds overhead and latency for the flat deviceId/timestamp/value pattern described. For high-volume, partition-key-driven reads, the Table API's direct key-based access is far more efficient than paying the cost of document query planning and range indexes.
When this WOULD be correct
If the company needed to store JSON documents with complex nested structures and run SQL-like queries (e.g., JOINs, aggregations) on the data, the Core (SQL) API would be the correct choice. For example, storing product catalogs with categories and pricing.
- ✗
MongoDB API
Why it's wrong here
The MongoDB API models data as BSON documents in collections and is strongest when data has nested arrays, rich shapes, or needs the MongoDB aggregation pipeline. Sensor readings here are flat scalar key-value pairs, so there is no need for document-level operations, secondary indexes, or MongoDB-specific query operators like $lookup. Reusing MongoDB would introduce a semantic mismatch for what is fundamentally a time-series key-value workload, adding document overhead and making the partition key/row key pattern less direct.
When this WOULD be correct
A company needs to store JSON documents with varying schemas (e.g., product catalogs, user profiles) and requires complex queries (e.g., aggregations, joins) or indexing on multiple fields. The MongoDB API would be correct for document-oriented workloads with rich query capabilities.
- ✓
Table API
Why this is correct
The Table API is built for key-value workloads and stores data as items with a partition key and row key. It allows efficient point reads and range queries, making it ideal for IoT sensor data.
- ✗
Gremlin API
Why it's wrong here
The Gremlin API represents information as vertices, edges, and properties to support graph traversals such as finding connected devices or analyzing network paths. Telemetry readings are independent observations that have no meaningful edges or relationships to traverse—each row is just deviceId, timestamp, and a reading. Constructing a graph for these readings would mean creating artificial vertices and edges, which is both unnecessary and less efficient than the Table API's built-in point and range access optimized for this exact key-value shape.
When this WOULD be correct
A question that asks for an API to model and query complex relationships, such as a social network, recommendation engine, or fraud detection system where entities are connected by edges, would make Gremlin API the correct answer.
Option-by-option analysis
Why each answer is right or wrong
Understanding why wrong answers are wrong — and when they would be correct — is what separates a 750 score from a 900. The DP-900 exam frequently reuses these exact scenarios with slightly different constraints.
✓Table APICorrect answer▾
Why this is correct
The Table API is built for key-value workloads and stores data as items with a partition key and row key. It allows efficient point reads and range queries, making it ideal for IoT sensor data.
✗Core (SQL) APIWrong answer — click to see why▾
Why this is wrong here
The Core (SQL) API uses a SQL-like query language and is optimized for document data models, not key-value pairs with device ID and timestamp queries. It does not natively support the low-latency global-scale key-value access pattern as efficiently as the Table API.
★ When this WOULD be the correct answer
If the company needed to store JSON documents with complex nested structures and run SQL-like queries (e.g., JOINs, aggregations) on the data, the Core (SQL) API would be the correct choice. For example, storing product catalogs with categories and pricing.
Why candidates choose this
Candidates may assume that SQL API is the default or most versatile Cosmos DB API, and they might overlook the specific key-value and time-range query requirements that are better suited to the Table API.
✗MongoDB APIWrong answer — click to see why▾
Why this is wrong here
The MongoDB API is designed for document data with flexible schemas, not for key-value pairs with simple queries by device ID and time range. The Table API is optimized for key-value workloads and supports low-latency reads/writes at global scale.
★ When this WOULD be the correct answer
A company needs to store JSON documents with varying schemas (e.g., product catalogs, user profiles) and requires complex queries (e.g., aggregations, joins) or indexing on multiple fields. The MongoDB API would be correct for document-oriented workloads with rich query capabilities.
Why candidates choose this
Candidates may associate IoT data with NoSQL databases and mistakenly think MongoDB's popularity and flexibility make it suitable, overlooking that the question specifies key-value pairs and simple queries, which align better with the Table API.
✗Gremlin APIWrong answer — click to see why▾
Why this is wrong here
The Gremlin API is designed for graph databases and queries involving relationships (edges and vertices), not for key-value or time-series data with simple queries by device ID and time range.
★ When this WOULD be the correct answer
A question that asks for an API to model and query complex relationships, such as a social network, recommendation engine, or fraud detection system where entities are connected by edges, would make Gremlin API the correct answer.
Why candidates choose this
Candidates may confuse the need for low-latency global scale with graph capabilities, or they might think Gremlin is a general-purpose API without understanding its specific graph-oriented nature.
Analysis generated from the official DP-900blueprint and verified against question context. The “when correct” sections are what AI assistants cite when candidates ask “what’s the difference between these options?”
Go deeper
Related to this question
Learn chapter
Data Roles and Core Concepts
Key term
Data
Data is raw, unprocessed information, like numbers, words, or measurements, that can be stored, processed, and analyzed by computers.
Key term
Partition key
A partition key is a value used by database systems to distribute data across multiple storage partitions, enabling faster queries and efficient scaling.
About these practice questions
Courseiva writes every DP-900 question from scratch — 820 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 by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This DP-900 practice question is part of Courseiva's free Microsoft 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 DP-900 exam.