Free DP-420 Practice Test Questions and Answers (2026)

Batch size: An integer that represents how many objects are being written to Cosmos DB collection in

each batch. Usually, starting with the default batch size is sufficient. To further tune this value, note:

Cosmos DB limits single request's size to 2MB. The formula is "Request Size = Single Document Size *

Batch Size". If you hit error saying "Request size is too large", reduce the batch size value.

The larger the batch size, the better throughput the service can achieve, while make sure you

allocate enough RUs to empower your workload.

Incorrect Answers:

A: Throughput: Set an optional value for the number of RUs you'd like to apply to your CosmosDB

collection for each execution of this data flow. Minimum is 400.

B: Write throughput budget: An integer that represents the RUs you want to allocate for this Data

Flow write operation, out of the total throughput allocated to the collection.

D: Collection action: Determines whether to recreate the destination collection prior to writing.

None: No action will be done to the collection.

Recreate: The collection will get dropped and recreated

Reference: https://docs.microsoft.com/en-us/azure/data-factory/connector-azure-cosmos-db

:

The indexing policy has an includedPaths array that contains only one path: /product/brand/? . This

means that only the properties under /product/brand will be indexed. The ? symbol indicates that

only scalar values will be indexed, not arrays or objects1.

The excludedPaths array contains a single path: /* . This means that all other properties will be

excluded from indexing. The * symbol indicates a wildcard that matches any property name1.

Therefore, the paths /product/category , /product/[ ]/category , and /product/brand/tailspin will not

be indexed.

The partition key is what will determine how data is routed in the various partitions by Cosmos DB

and needs to make sense in the context of your specific scenario. The IoT Device ID is generally the

"natural" partition key for IoT applications.

Scenario: The iotdb database will contain two containers named con-iot1 and con-iot2.

Ensure that Azure Cosmos DB costs for IoT-related processing are predictable.

Reference:

https://docs.microsoft.com/en-us/azure/architecture/solution-ideas/articles/iot-using-cosmos-db

Box 1 = Range

Azure Cosmos DB supports three types of indexes: range, spatial and composite. For the query you

provided, which is an equality query on a single property, the best type of index to use

is range. Range index is based on an ordered tree-like structure and it is used for equality queries,

range queries and checking for the presence of a property1. Range index also supports any string or

number2.

Box 2 = Composite

Azure Cosmos DB supports three types of indexes: range, spatial and composite. For the query you

provided, which is an order by query on two properties, the best type of index to use

is composite. Composite index is used for optimizing order by queries on multiple

properties1. Composite index allows you to specify a list of property paths and sort orders that are

used for ordering items2.

Box 3 = spatial

Azure Cosmos DB supports three types of indexes: range, spatial and composite. For the query you

provided, which is a spatial query on a point property, the best type of index to use is spatial. Spatial

index is used for querying items based on their location or proximity to a given point1. Spatial index

supports point, polygon and linestring data types2.

According to the Azure Cosmos DB documentation1, Always Encrypted is a feature designed to

protect sensitive data, such as credit card numbers or national identification numbers, stored in

Azure Cosmos DB. Always Encrypted allows clients to encrypt sensitive data inside client applications

and never reveal the encryption keys to the database.

To use Always Encrypted, you need to define an encryption policy for each container that specifies

which properties should be encrypted and which data encryption keys (DEK) should be used. The

DEKs are stored in Azure Cosmos DB and are wrapped by customer-managed keys (CMK) that are

stored in Azure Key Vault.

Based on the encryption policy shown in the exhibits, the creditcard property is encrypted with a DEK

named dek1, and the SSN property is encrypted with a DEK named dek2. Both DEKs are wrapped by

a CMK named cmk1.

To answer your statements:

You can perform a query that filters on the creditcard property = No. This is because the creditcard

property is encrypted and cannot be used for filtering or sorting operations1.

You can perform a query that filters on the SSN property = No. This is also because the SSN property

is encrypted and cannot be used for filtering or sorting operations1.

An application can be allowed to read the creditcard property while being restricted from reading the

SSN property = Yes. This is possible by using different CMKs to wrap different DEKs and applying

access policies on the CMKs in Azure Key Vault. For example, if you use cmk2 to wrap dek2 instead of

cmk1, you can grant an application access to cmk1 but not cmk2, which means it can read the

creditcard property but not the SSN property2.

This is because the write concern is mapped to the default consistency level configured on your

Azure Cosmos DB account, which is strong in this case. Strong consistency ensures that every write

operation is synchronously committed to every region associated with your Azure Cosmos DB

account. The eventual consistency level that the application uses only applies to the read operations.

Eventual consistency offers higher availability and better performance, but it does not guarantee the

order or latency of the reads.

:

:

The following are the operation names in diagnostic logs for different operations:

RegionAddStart, RegionAddComplete

RegionRemoveStart, RegionRemoveComplete

AccountDeleteStart, AccountDeleteComplete

RegionFailoverStart, RegionFailoverComplete

AccountCreateStart, AccountCreateComplete

*AccountUpdateStart*, AccountUpdateComplete

VirtualNetworkDeleteStart, VirtualNetworkDeleteComplete

DiagnosticLogUpdateStart, DiagnosticLogUpdateComplete

Reference: https://docs.microsoft.com/en-us/azure/cosmos-db/audit-control-plane-logs

The solution is incorrect because there is no "isTom" parameter in the Azure Cosmos DB SDK. The

correct parameter is "isTombstone".

https://kxbjsyuhceggsyvxdkof.supabase.co/storage/v1/object/public/file-images/DP-420/page_81_img_2.jpg

https://kxbjsyuhceggsyvxdkof.supabase.co/storage/v1/object/public/file-images/DP-420/page_23_img_2.jpg

Step 1: Configure the MaxItemCount in QueryRequestOptions

You can specify the maximum number of items returned by a query by setting the MaxItemCount.

The MaxItemCount is specified per request and tells the query engine to return that number of items

or fewer.

Box 2: Run the query and provide a continuation token

In the .NET SDK and Java SDK you can optionally use continuation tokens as a bookmark for your

query's progress. Azure Cosmos DB query executions are stateless at the server side and can be

resumed at any time using the continuation token.

If the query returns a continuation token, then there are additional query results.

Step 3: Append the results to a variable

Reference: https://docs.microsoft.com/en-us/azure/cosmos-db/sql/sql-query-pagination

https://kxbjsyuhceggsyvxdkof.supabase.co/storage/v1/object/public/file-images/DP-420/page_53_img_3.jpg

Box 1: No

Each physical partition should have its own index, but since no index is used, the query is not cross-

partition.

Box 2: No

Index utilization is 0% and Index Look up time is also zero.

Box 3: Yes

A partition key index will be created, and the query will perform across the partitions.

Reference: https://docs.microsoft.com/en-us/azure/cosmos-db/sql/how-to-query-container

https://kxbjsyuhceggsyvxdkof.supabase.co/storage/v1/object/public/file-images/DP-420/page_86_img_2.jpg

https://kxbjsyuhceggsyvxdkof.supabase.co/storage/v1/object/public/file-images/DP-420/page_28_img_3.jpg

Box 1: No

Four containers with 1000 RU/s each.

Box 2: No

Max 8000 RU/s for db2. 8 containers, so 1000 RU/s for each container.

Box 3: Yes

Max 8000 RU/s for db2. 8 containers, so 1000 RU/s for each container. Can very well add an

additional container.

Reference:

https://docs.microsoft.com/en-us/azure/cosmos-db/plan-manage-costs

https://azure.microsoft.com/en-us/pricing/details/cosmos-db/

Azure Cosmos DB supports queries with parameters expressed by the familiar @ notation.

Parameterized SQL provides robust handling and escaping of user input, and prevents accidental

exposure of data through SQL injection.

For example, you can write a query that takes lastName and address.state as parameters, and

execute it for various values of lastName and address.state based on user input.

SELECT *

FROM Families f

WHERE f.lastName = @lastName AND f.address.state = @addressState

Reference: https://docs.microsoft.com/en-us/azure/cosmos-db/sql/sql-query-parameterized-queries

Azure Cosmos DB is a multi-model database that supports various data models, such as documents,

key-value, graph, and column-family3. The core content-model of Cosmos DB’s database engine is

based on atom-record-sequence (ARS), which allows it to store and query different types of data in a

flexible and efficient way3.

To develop a model that supports order read operations and minimizes the number of requests, you

should consider the following factors:

The size and shape of your data

The frequency and complexity of your queries

The latency and throughput requirements of your application

The trade-offs between storage efficiency and query performance

Based on these factors, one possible model that you could implement is B. Create a single database

that contains one container. Create a separate document for each order and embed the order items

into the order documents.

This model has the following advantages:

It stores orders and order items as self-contained documents that can be easily retrieved by order

ID1.

It avoids storing redundant data or creating additional containers for order items1.

It allows you to view the order history of a customer with simple queries1.

It leverages the benefits of embedding data, such as reducing the number of requests, improving

query performance, and simplifying data consistency2.

This model also has some limitations, such as:

It may not be suitable for some order items that have data that is greater than 2 KB, as it could

exceed the maximum document size limit of 2 MB2.

It may not be optimal for scenarios where order items need to be queried independently from orders

or aggregated by other criteria2.

It may not support transactions across multiple orders or customers, as transactions are scoped to a

single logical partition2.

Depending on your specific use case and requirements, you may need to adjust this model or choose

a different one. For example, you could use a hybrid data model that combines embedding and

referencing data2, or you could use a graph data model that expresses entities and relationships as

vertices and edges.

Reference: https://docs.microsoft.com/en-us/azure/cosmos-db/how-to-setup-cmk

You can facilitate aggregate data by using Change Feed and Azure Functions, and then use it for

reporting.

Reference: https://docs.microsoft.com/en-us/azure/cosmos-db/change-feed