50 Microsoft Certified: Azure Cosmos DB Developer Specialty Practice Questions: Question Bank 2025

You are designing an Azure Cosmos DB for NoSQL container to store user profiles. Each profile is frequently retrieved by userId, and the application occasionally filters by country. Most requests read a single profile by id and partition key. Which partition key choice is recommended to optimize point reads and scalability?

An application uses Azure Cosmos DB for NoSQL and must enforce uniqueness of an email address within a logical tenant. You want the database to reject duplicates at write time without using stored procedures. What should you implement?

You need to process changes from an Azure Cosmos DB for NoSQL container in near real time to update a cache. The processor must scale out across multiple instances and ensure each change is processed at least once. Which feature should you use?

A team notices that queries filtering on a property are returning correct results but are consuming more RU/s than expected. They suspect the queries are not using an index. What is the FIRST thing they should check in the query results to confirm index usage?

You store orders in a container partitioned by /customerId. A new requirement needs efficient queries that return the most recent orders for a customer sorted by orderDate. Which indexing approach best supports this query pattern?

An Azure Cosmos DB for NoSQL container is partitioned by /deviceId. Telemetry writes are evenly distributed, but one device generates far more events than others, causing throttling for that device's partition. You need to reduce hot partition risk while still supporting queries by deviceId. What is the best design change?

A microservice must call Azure Cosmos DB for NoSQL. Security policy prohibits secrets in configuration files and requires automatic credential rotation. The service runs on Azure Kubernetes Service (AKS). What is the recommended authentication approach?

Your container uses session consistency. Users report occasionally seeing stale data immediately after updating a document, but only when requests are routed through a different application instance. Each application instance uses its own CosmosClient. What is the most likely cause?

You need to design a multi-region Azure Cosmos DB for NoSQL solution that supports active-active writes. The application must automatically resolve write conflicts, and business rules require that "highest priority" updates win. Which conflict resolution strategy should you choose?

A high-throughput workload uses the Azure Cosmos DB for NoSQL SDK. You observe intermittent 429 (RequestRateTooLarge) responses and increased latency during peak periods. You want to reduce end-to-end latency while keeping request success rates high, without simply increasing RU/s. What should you do in the application?

You are building an order-tracking API using Azure Cosmos DB for NoSQL. Most requests read an order by orderId and need to include the customerId and currentStatus. Which modeling approach best minimizes RU consumption for these point reads?

An application uses Azure Cosmos DB for NoSQL with the SQL API. You need to ensure that a set of operations (create an order, create its line items, and decrement inventory) are atomic. What should you use?

You need to read changes from a container in Azure Cosmos DB for NoSQL to update a search index in near real time. Which feature is designed for this purpose?

A container uses partition key /tenantId. A new requirement requires querying invoices by invoiceNumber, and invoiceNumber is only unique within a tenant. The API must do a fast lookup with minimal RU and latency. What should you implement?

You are designing a multi-tenant SaaS solution. Tenant A generates 10x more traffic than other tenants, causing uneven RU consumption when using /tenantId as the partition key. You need to improve distribution while still being able to query by tenant efficiently. What is the best approach?

A Cosmos DB for NoSQL container stores IoT telemetry. You want data to expire automatically 7 days after ingestion while keeping metadata documents indefinitely. Which approach should you use?

You run a query that filters on two properties (category and createdDate) and sorts by createdDate. The query is slow and consumes high RU. You want to optimize it without changing application behavior. What should you do?

Your application uses Azure Cosmos DB for NoSQL. You need to integrate with Azure Functions so that each time an item is inserted or updated, a function runs to transform and push the data to another system. You want minimal code and reliable checkpointing. What should you use?

A globally distributed app uses multi-region writes. Occasionally, users report seeing stale values for a short time after an update from another region. You need to minimize conflicts and ensure deterministic resolution when concurrent updates occur. What should you configure?

A container has a large number of logical partitions and uses autoscale throughput. During a load test, you observe intermittent 429 (Request rate too large) responses even though average RU usage is below the autoscale max. The workload targets a small set of partition key values. What is the most likely cause and best fix?

You are building an API that reads items from a single Azure Cosmos DB for NoSQL container. You need each query request to return an additional field showing the RU charge for that request so the client can display it. What should you do?

A team is troubleshooting a query that frequently returns HTTP 429 (RequestRateTooLarge). They want to implement a retry strategy in the application using the Azure Cosmos DB SDK. What is the recommended approach?

You have a container with a partition key of /customerId. Your application needs to read a single item when both id and customerId are known. Which operation is recommended to minimize RU consumption and latency?

You are designing a data model for a multi-tenant SaaS application using Azure Cosmos DB for NoSQL. Each tenant can have up to 50 million documents. Queries are typically scoped to a tenant and filter by a time range. You need to minimize hot partitions while keeping tenant-scoped queries efficient. Which partition key design is best?

Your application requires that whenever a new order item is created in a container, a corresponding summary document in the same container is updated (for example, incrementing an orderTotal). The update must execute atomically with the create operation within a single logical partition. What should you use?

You need to integrate Azure Cosmos DB for NoSQL with an upstream service that supports only OData-style queries. You want minimal transformation effort and want the upstream service to query Cosmos DB items using OData conventions. Which feature should you use?

A container stores product documents that include an array of tags. You need to support queries like: "find products where tags contains 'outdoor'" and "find products where tags contains any of ['outdoor','camping']". You want to optimize these queries without denormalizing into multiple documents. What should you do?

Your workload writes into a container and uses Change Feed to project data into a separate read-optimized container. During a failover test, you observe that the projection sometimes reprocesses a small set of changes, creating duplicate projected records. You need idempotent processing. What is the best approach?

You have a container with a partition key of /deviceId. A query must retrieve the latest 50 telemetry items for a given device ordered by timestamp descending. The query frequently times out under load. You want to optimize query performance and RU usage. What should you do?

You must design a container to store IoT events. Each event includes deviceId, eventType, and eventTime. Writes are evenly distributed across devices, but reads are mostly for dashboards that aggregate by eventType over the last hour across all devices. You need to minimize RU for these dashboard queries without sacrificing write scalability. Which design is best?

You are building a Cosmos DB for NoSQL solution that stores customer profiles. Each profile contains an array of addresses. The application frequently retrieves a single address by its addressId without returning the rest of the profile. What is the recommended approach to reduce RU consumption and payload size?

A container uses the partition key path /tenantId. Your query filters by tenantId and includes ORDER BY c.createdAt. The query frequently returns 429 (Request rate too large) due to high RU usage. What change is most likely to reduce RU consumption for this query pattern?

You need to ingest change events from a Cosmos DB for NoSQL container into an Azure Function for near real-time processing. You must ensure events are processed in order per logical partition key and support scale-out. Which integration should you use?

Your application uses point reads by id and partition key for most operations. Some items are missing the correct partition key value due to a bug, causing reads to fail. You need to quickly find these bad items without scanning the entire container client-side. What should you do?

A global application writes user activity events. Each event includes userId and eventTime. The primary access pattern is: retrieve the last 100 events for a given user ordered by eventTime descending. Which partition key choice best supports this pattern at scale?

You are using the .NET SDK to upsert items into a Cosmos DB for NoSQL container. You want to minimize RU usage when an item has not changed. What should you implement?

You observe that a query filtering on c.category and c.status is consuming high RU and often performing full scans. The indexing policy currently includes all paths. What is the most likely cause and fix?

You need to enforce that when an order is created, the inventory count for each item is decremented atomically with the order write. All affected records share the same partition key value (storeId). What is the best approach in Cosmos DB for NoSQL?

Your workload has unpredictable spikes. You want the database to automatically add RU/s during spikes and scale down afterward, while setting an upper limit to control consumption. Which capability should you use?

A container stores IoT telemetry with partition key /deviceId. Some devices generate far more events than others, causing throttling on those hot partitions. You cannot change the partition key for existing data. What is the most effective mitigation strategy for new writes while keeping existing reads functional?

You are building a .NET API that uses the Azure Cosmos DB for NoSQL SDK. Each request reads a single item by id and partition key. Which approach is recommended to minimize latency and connection overhead?

A container uses partition key path /customerId. A query filters only on a non-key field (e.g., WHERE status = 'Open') and is frequently run by your application. You want to ensure the query targets the correct partitions when you know the customerId at runtime. What should you do in the SDK request?

You need to insert documents into a container and ensure the operation fails if a document with the same id and partition key already exists. Which operation should you use?

Your team stores IoT telemetry with fields: deviceId, ts, temperature, humidity, and a large debugPayload object used rarely. Most queries filter by deviceId and ts range and return only temperature and humidity. You want to reduce RU consumption for these queries without changing query patterns. What should you do?

A query frequently returns only a small subset of fields from large documents. You want to reduce network transfer and client-side deserialization cost. Which query pattern should you use?

You are designing a container for order data. Each order has orderId, customerId, and an array of line items. Most operations are: (1) read a single order by orderId, (2) list all orders for a customer, and (3) update order status. Which partition key is the best choice to balance query efficiency and scalability?

A container receives a sustained write-heavy workload. You observe that writes have higher RU consumption than expected and query patterns are simple point reads and single-partition lookups. You suspect indexing overhead is too high. Which change is most appropriate?

You are integrating Azure Cosmos DB change feed into an event-driven pipeline. You must ensure each change is processed at least once and you need automatic tracking of progress across restarts. Which approach is recommended?

You need to atomically update two items in Azure Cosmos DB for NoSQL: decrement inventory for a product and append an entry to a per-product audit document. Both items share the same partition key value (productId). What should you use?

Your container is partitioned by /tenantId. You must support a query that returns the 50 most recent invoices across ALL tenants, ordered by invoiceDate descending, with low latency. Tenants are evenly distributed and invoice volume is high. What design is recommended?