{"id":16503,"date":"2026-09-19T07:53:35","date_gmt":"2026-09-19T07:53:35","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=16503"},"modified":"2026-09-19T07:53:35","modified_gmt":"2026-09-19T07:53:35","slug":"microsoft-dp-420-practice-test-questions-and-exam-dumps-part4-q61-80","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/microsoft-dp-420-practice-test-questions-and-exam-dumps-part4-q61-80\/","title":{"rendered":"Microsoft DP-420 Practice Test Questions and Exam Dumps Part4 Q61-80"},"content":{"rendered":"

 <\/p>\n

View Full <\/b>Microsoft DP-420 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Q1. You are designing a Cosmos DB container that will store customers, orders, and addresses. These entities share the same tenant boundary and are frequently queried together. Which modeling technique should you consider?<\/b><\/p>\n

    \n
  1. <\/b> Create a separate Azure subscription for every entity type.<\/span><\/li>\n
  2. <\/b> Store every property as a string.<\/span><\/li>\n
  3. <\/b> Use one physical partition for the entire application.<\/span><\/li>\n
  4. <\/b> Store multiple entity types in the same container when their partitioning and access patterns align.<\/span><\/li>\n<\/ol>\n

    Correct Answer: 4. Store multiple entity types in the same container when their partitioning and access patterns align.<\/b><\/p>\n

    Explanation:<\/b> Azure Cosmos DB does not require one container per entity type. Multiple related entity types can share a container when they have compatible partitioning requirements and access patterns. A type discriminator property can identify whether each document represents a customer, order, address, or another entity. This approach can simplify transactional access and reduce unnecessary cross-container operations. It should not be used blindly; entities with very different throughput, retention, security, or partitioning needs may benefit from separate containers. Cosmos DB modeling focuses primarily on workload access patterns rather than traditional relational table boundaries.<\/span><\/p>\n

    Q2. You are deciding whether to embed an address inside a customer document or store the address separately. The address is small, belongs to only one customer, and is almost always read with the customer. What should you do?<\/b><\/p>\n

      \n
    1. <\/b> Embed the address in the customer document.<\/span><\/li>\n
    2. <\/b> Create a separate database account for addresses.<\/span><\/li>\n
    3. <\/b> Store the address only in Azure Blob Storage.<\/span><\/li>\n
    4. <\/b> Create one container for each address.<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. Embed the address in the customer document.<\/b><\/p>\n

      Explanation:<\/b> Embedding is usually appropriate when related data has the same lifecycle, remains reasonably small, and is typically retrieved with its parent. Storing the address inside the customer document reduces the need for additional reads and avoids client-side joins. Referencing a separate document can be useful when the related entity is large, independently updated, or shared by many parent entities. Azure Cosmos DB encourages denormalization when it improves the dominant access pattern. The design must still respect item-size limits and consider whether frequent embedded updates would cause unnecessary write costs.<\/span><\/p>\n

      Q3. Your application stores product data and category data in different documents. Many products reference the same category, and category descriptions change independently. Which approach is most suitable?<\/b><\/p>\n

        \n
      1. <\/b> Copy the entire category document into every product and never update it.<\/span><\/li>\n
      2. <\/b> Store each category property as a partition key.<\/span><\/li>\n
      3. <\/b> Reference the category document from product documents.<\/span><\/li>\n
      4. <\/b> Disable indexing on the product container.<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. Reference the category document from product documents.<\/b><\/p>\n

        Explanation:<\/b> Referencing is often more appropriate when a related entity is shared by many documents and changes independently. If hundreds of products use the same category, embedding the full category data in every product can create extensive duplication and require many updates whenever the category changes. A product can instead contain a category identifier that the application uses to retrieve or resolve category details. This introduces extra reads compared with embedding, so the correct design depends on the read and update patterns. Cosmos DB modeling frequently balances denormalization against consistency and duplication costs.<\/span><\/p>\n

        Q4. A container is expected to store billions of records. You need to choose a partition key. Which characteristic is most desirable?<\/b><\/p>\n

          \n
        1. <\/b> Very low cardinality.<\/span><\/li>\n
        2. <\/b> High cardinality with values that distribute storage and request volume evenly.<\/span><\/li>\n
        3. <\/b> A value that is identical for every item.<\/span><\/li>\n
        4. <\/b> A property that is never known by the application.<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2. High cardinality with values that distribute storage and request volume evenly.<\/b><\/p>\n

          Explanation:<\/b> A strong partition key should have sufficient cardinality to spread data across logical and physical partitions while also distributing request-unit consumption. A key with only a few values can cause hot partitions and constrain scalability. The partition key should also align with common query and transaction boundaries so operations can be efficiently routed. Using the same value for every item would concentrate the workload in one logical partition. Partition-key selection is difficult to change after deployment, so expected growth, query patterns, and throughput distribution should all be considered during design.<\/span><\/p>\n

          Q5. You estimate that an application will have irregular traffic but must occasionally handle large bursts while maintaining provisioned throughput guarantees. Which throughput model is appropriate?<\/b><\/p>\n

            \n
          1. <\/b> Autoscale provisioned throughput.<\/span><\/li>\n
          2. <\/b> Disable throughput management.<\/span><\/li>\n
          3. <\/b> TTL-based throughput.<\/span><\/li>\n
          4. <\/b> Change-feed throughput.<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. Autoscale provisioned throughput.<\/b><\/p>\n

            Explanation:<\/b> Autoscale provisioned throughput allows Azure Cosmos DB to automatically scale RU\/s between a lower level and a configured maximum based on demand. It is useful when workloads fluctuate significantly but still require the performance and capacity characteristics of provisioned throughput. Manual provisioned throughput can work for predictable workloads, while serverless may be suitable for intermittent workloads within supported limits. TTL and change feed are unrelated to capacity allocation. Autoscale can reduce the operational burden of manually adjusting throughput during variable traffic periods while maintaining a defined maximum capacity.<\/span><\/p>\n

            Q6. You are building a development environment and want to test Azure Cosmos DB application code locally without provisioning a cloud account. What should you use?<\/b><\/p>\n

              \n
            1. <\/b> Azure Monitor Workbooks.<\/span><\/li>\n
            2. <\/b> Azure Data Factory.<\/span><\/li>\n
            3. <\/b> Azure AI Search.<\/span><\/li>\n
            4. <\/b> Azure Cosmos DB emulator.<\/span><\/li>\n<\/ol>\n

              Correct Answer: 4. Azure Cosmos DB emulator.<\/b><\/p>\n

              Explanation:<\/b> The Azure Cosmos DB emulator provides a local environment for developing and testing Cosmos DB applications without requiring a live Azure account. It is useful for local development, automated testing, and experimentation with SDK behavior. The emulator does not replace production validation because cloud deployment characteristics such as global distribution and real network latency differ. Azure Monitor is for observability, Data Factory is for data integration, and Azure AI Search provides search capabilities. The emulator is specifically intended to make Cosmos DB development easier and less expensive during local testing.<\/span><\/p>\n

              Q7. Your corporate firewall permits only HTTPS traffic through port 443. Which Azure Cosmos DB SDK connectivity mode should you consider?<\/b><\/p>\n

                \n
              1. <\/b> Offline mode.<\/span><\/li>\n
              2. <\/b> Gateway mode.<\/span><\/li>\n
              3. <\/b> Analytical mode.<\/span><\/li>\n
              4. <\/b> Backup mode.<\/span><\/li>\n<\/ol>\n

                Correct Answer: 2. Gateway mode.<\/b><\/p>\n

                Explanation:<\/b> Gateway mode routes SDK requests through the Azure Cosmos DB gateway over HTTPS and is often useful when network environments restrict outbound connectivity. Direct mode generally provides lower latency and higher throughput by communicating more directly with backend replicas, but it can require additional networking considerations. Gateway mode may therefore be preferable in tightly controlled environments where HTTPS traffic is the practical option. The choice of connectivity mode should account for network restrictions, expected performance, deployment topology, and operational requirements rather than being selected solely for convenience.<\/span><\/p>\n

                Q8. You are querying documents with a nested <\/b>address<\/b> object and need to return only items where <\/b>address.city<\/b> equals <\/b>“Seattle”<\/b>. What should your SQL query do?<\/b><\/p>\n

                  \n
                1. <\/b> Convert the entire document to a string first.<\/span><\/li>\n
                2. <\/b> Use a stored procedure for every read.<\/span><\/li>\n
                3. <\/b> Reference the nested property directly in the query predicate.<\/span><\/li>\n
                4. <\/b> Disable the index.<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. Reference the nested property directly in the query predicate.<\/b><\/p>\n

                  Explanation:<\/b> Azure Cosmos DB for NoSQL SQL can query nested object properties directly using property-path notation. A predicate can reference a field such as <\/span>c.address.city<\/span> and compare it with the required value. JSON documents do not need to be flattened before every query. Stored procedures are not required for standard reads, and disabling indexing would generally increase query cost for indexed lookups. Understanding how to query nested objects and arrays is important because Cosmos DB documents commonly use hierarchical JSON structures rather than flat relational rows.<\/span><\/p>\n

                  Q9. A query needs to calculate the square root of a numeric property for every matching document. Which capability should you use?<\/b><\/p>\n

                    \n
                  1. <\/b> A mathematical SQL function.<\/span><\/li>\n
                  2. <\/b> TTL.<\/span><\/li>\n
                  3. <\/b> Manual failover.<\/span><\/li>\n
                  4. <\/b> A continuation token.<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. A mathematical SQL function.<\/b><\/p>\n

                    Explanation:<\/b> Azure Cosmos DB for NoSQL SQL provides built-in mathematical functions that can perform calculations on numeric properties within queries. Using built-in functions is usually simpler and more efficient than retrieving every document and performing the calculation entirely in application code. TTL controls expiration, manual failover changes regional roles, and continuation tokens support pagination. Query functions should still be used thoughtfully because calculations over large datasets can consume significant request units, particularly if predicates cannot efficiently use indexes to reduce the number of examined documents.<\/span><\/p>\n

                    Q10. You need to retrieve all values from an array property and flatten them into individual query results. Which SQL construct is commonly used?<\/b><\/p>\n

                      \n
                    1. <\/b> TTL.<\/span><\/li>\n
                    2. <\/b> JOIN over the array.<\/span><\/li>\n
                    3. <\/b> Backup restore.<\/span><\/li>\n
                    4. <\/b> Manual failover.<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2. JOIN over the array.<\/b><\/p>\n

                      Explanation:<\/b> Azure Cosmos DB SQL supports JOIN operations within a single document to iterate over arrays and produce results for their elements. This is different from relational joins between independent tables or containers. For example, a JOIN can enumerate items in a product’s <\/span>tags<\/span> or <\/span>categories<\/span> array and return matching elements. TTL, backup restore, and failover are operational features unrelated to JSON-array traversal. Developers should understand that Cosmos DB JOIN semantics are scoped to data within an item rather than arbitrary cross-document relational joins.<\/span><\/p>\n

                      Q11. You need server-side JavaScript logic that executes before an explicitly invoked item write and can modify the document before it is stored. Which object should you create?<\/b><\/p>\n

                        \n
                      1. <\/b> Change feed processor.<\/span><\/li>\n
                      2. <\/b> Composite index.<\/span><\/li>\n
                      3. <\/b> Pre-trigger.<\/span><\/li>\n
                      4. <\/b> Continuation token.<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3. Pre-trigger.<\/b><\/p>\n

                        Explanation:<\/b> A pre-trigger is JavaScript logic that runs before an item operation when the client explicitly requests the trigger. It can validate or modify the item before the database completes the operation. Triggers do not automatically execute for every request; the client must specify them. A change feed processor reacts asynchronously to changes, a composite index optimizes query patterns, and continuation tokens support query pagination. Server-side triggers can be useful for certain validation or transformation scenarios, although application-side logic is often easier to maintain.<\/span><\/p>\n

                        Q12. You need JavaScript code that performs several item operations transactionally within one logical partition and is executed on the server. What should you create?<\/b><\/p>\n

                          \n
                        1. <\/b> Integrated cache.<\/span><\/li>\n
                        2. <\/b> Unique key policy.<\/span><\/li>\n
                        3. <\/b> Change feed estimator.<\/span><\/li>\n
                        4. <\/b> Stored procedure.<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 4. Stored procedure.<\/b><\/p>\n

                          Explanation:<\/b> Stored procedures are server-side JavaScript functions that execute within the scope of a logical partition. They can perform multiple item operations as part of a transaction, meaning the operations succeed or fail together. Because transactional scope is limited to one logical partition, the partition key must be chosen carefully if stored-procedure transactions are required. Integrated cache improves eligible reads, unique keys enforce constraints, and the change feed estimator monitors change-processing lag. Stored procedures are appropriate for specialized transactional server-side workflows.<\/span><\/p>\n

                          Q13. Your Cosmos DB account uses one write region. You need to move the write role intentionally to another configured region during planned maintenance. What should you perform?<\/b><\/p>\n

                            \n
                          1. <\/b> Change the TTL.<\/span><\/li>\n
                          2. <\/b> Manual failover.<\/span><\/li>\n
                          3. <\/b> Rebuild every index.<\/span><\/li>\n
                          4. <\/b> Delete and recreate the account.<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 2. Manual failover.<\/b><\/p>\n

                            Explanation:<\/b> Manual failover allows administrators to intentionally change the write region in a single-write-region Cosmos DB account. This can be useful during planned maintenance, testing, or operational exercises. Automatic failover, by contrast, can promote another region when an outage occurs according to configured priorities. TTL and indexing do not control regional write roles, and recreating the account would be unnecessary. Failover planning is an important part of designing resilient globally distributed applications and should be tested before a real incident occurs.<\/span><\/p>\n

                            Q14. Your application needs the lowest possible read latency and can tolerate temporarily stale data. Which consistency level should you evaluate?<\/b><\/p>\n

                              \n
                            1. <\/b> Strong.<\/span><\/li>\n
                            2. <\/b> Session only.<\/span><\/li>\n
                            3. <\/b> Bounded staleness only.<\/span><\/li>\n
                            4. <\/b> Eventual.<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 4. Eventual.<\/b><\/p>\n

                              Explanation:<\/b> Eventual consistency provides the weakest consistency guarantee and generally offers favorable latency and availability characteristics. Reads may temporarily return older versions of data, but replicas converge over time. This can be appropriate for workloads such as feeds, catalogs, or telemetry where immediate consistency is not essential. Strong consistency provides the strictest guarantees and typically has different latency and availability tradeoffs. Session and bounded staleness offer intermediate guarantees. The correct choice depends on how much staleness the business process can tolerate and what consistency behavior the application requires.<\/span><\/p>\n

                              Q15. You are estimating the cost impact of adding several Azure regions to a Cosmos DB account. Which factor should you consider?<\/b><\/p>\n

                                \n
                              1. <\/b> Global replication increases the storage and throughput-related cost of operating additional regions.<\/span><\/li>\n
                              2. <\/b> Additional regions are always free.<\/span><\/li>\n
                              3. <\/b> Regions affect only document IDs.<\/span><\/li>\n
                              4. <\/b> Replication disables request-unit billing.<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1. Global replication increases the storage and throughput-related cost of operating additional regions.<\/b><\/p>\n

                                Explanation:<\/b> Globally distributing Azure Cosmos DB data improves availability and latency for geographically dispersed applications, but additional regions have cost implications. Replicated storage and throughput must be considered when estimating total solution cost. Multi-region writes can add further architectural considerations, including conflict resolution and consistency behavior. Adding regions should therefore be justified by availability, latency, disaster recovery, or data-residency requirements. Global distribution is a powerful Cosmos DB capability, but it should be planned with both technical requirements and cost governance in mind.<\/span><\/p>\n

                                Q16. You need operational Cosmos DB data to appear in Microsoft Fabric with minimal custom ETL development. Which feature should you evaluate?<\/b><\/p>\n

                                  \n
                                1. <\/b> A SQL UDF.<\/span><\/li>\n
                                2. <\/b> Integrated cache.<\/span><\/li>\n
                                3. <\/b> Azure Cosmos DB Mirroring for Microsoft Fabric.<\/span><\/li>\n
                                4. <\/b> Session consistency.<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Azure Cosmos DB Mirroring for Microsoft Fabric.<\/b><\/p>\n

                                  Explanation:<\/b> Azure Cosmos DB Mirroring for Microsoft Fabric is intended to make Cosmos DB operational data available for Fabric analytics with less custom pipeline development. It can simplify integration compared with manually building ETL processes for every analytical workload. A UDF provides server-side query logic, integrated cache accelerates eligible operational reads, and session consistency affects data visibility guarantees. The choice between Mirroring and approaches such as Spark connectors should be based on whether the workload requires managed replication, direct Spark processing, or transactional-store read and write access.<\/span><\/p>\n

                                  Q17. You enabled analytical store and need a Spark workload to query it through Azure Synapse. What should you configure?<\/b><\/p>\n

                                    \n
                                  1. <\/b> A connection from Synapse Spark to the Cosmos DB analytical store.<\/span><\/li>\n
                                  2. <\/b> A manual failover.<\/span><\/li>\n
                                  3. <\/b> A unique key policy.<\/span><\/li>\n
                                  4. <\/b> A session token.<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. A connection from Synapse Spark to the Cosmos DB analytical store.<\/b><\/p>\n

                                    Explanation:<\/b> Analytical store is designed to support large-scale analytical processing separate from transactional request-unit workloads. A supported Azure Synapse Spark connection can query the analytical representation of Cosmos DB data for reporting, transformation, and advanced analytics. Manual failover affects regional roles, unique keys enforce constraints, and session tokens support session consistency for transactional operations. Analytical-store integration is useful when operational data must be analyzed without repeatedly issuing large scans against the transactional store.<\/span><\/p>\n

                                    Q18. You need to capture changes from Cosmos DB analytical store for downstream incremental processing. Which capability is relevant?<\/b><\/p>\n

                                      \n
                                    1. <\/b> TTL.<\/span><\/li>\n
                                    2. <\/b> Analytical store Change Data Capture.<\/span><\/li>\n
                                    3. <\/b> Unique key policy.<\/span><\/li>\n
                                    4. <\/b> Point reads.<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Analytical store Change Data Capture.<\/b><\/p>\n

                                      Explanation:<\/b> Change Data Capture for the analytical store supports incremental processing scenarios by identifying data changes that downstream analytics workflows need to process. This can reduce the need to repeatedly rescan full analytical datasets. TTL manages item expiration, unique keys enforce data integrity, and point reads retrieve individual transactional items. CDC is valuable in analytical pipelines where incremental movement or processing is more efficient than full reloads and is part of modern integration patterns involving Cosmos DB analytical workloads.<\/span><\/p>\n

                                      Q19. You need to investigate security-related activity and access patterns for a Cosmos DB account. Which operational capability should you use?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Integrated cache.<\/span><\/li>\n
                                      2. <\/b> Composite indexes.<\/span><\/li>\n
                                      3. <\/b> Logging and auditing through Azure Monitor resource logs.<\/span><\/li>\n
                                      4. <\/b> TTL.<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3. Logging and auditing through Azure Monitor resource logs.<\/b><\/p>\n

                                        Explanation:<\/b> Azure Monitor resource logs can provide detailed operational and diagnostic records for Cosmos DB activity. Routing these logs to a centralized destination such as Log Analytics supports investigation, security monitoring, auditing, and alerting. Integrated cache improves read performance, composite indexes improve certain query patterns, and TTL expires old items. Security monitoring should combine logging, access-control practices, network controls, and alerting so suspicious or unexpected activity can be detected and investigated effectively.<\/span><\/p>\n

                                        Q20. You need to restore only one accidentally deleted container to a prior point in time without rolling back unrelated containers. Which recovery approach should you use if continuous backup is configured?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Delete the entire account.<\/span><\/li>\n
                                        2. <\/b> Restore the affected container from an appropriate point-in-time restore point.<\/span><\/li>\n
                                        3. <\/b> Change the consistency level.<\/span><\/li>\n
                                        4. <\/b> Rebuild the composite indexes manually and expect the data to return.<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2. Restore the affected container from an appropriate point-in-time restore point.<\/b><\/p>\n

                                          Explanation:<\/b> Continuous backup supports point-in-time recovery workflows that can restore supported Cosmos DB resources to a selected time within the retention window. When only one container is affected, the recovery scope should be limited appropriately rather than disrupting unrelated data. Changing consistency or rebuilding indexes cannot recover deleted application data. A restore operation should use a verified restore point that predates the accidental deletion. Backup and restore procedures should be tested and documented so operators can respond quickly and confidently during production incidents.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                            View Full Microsoft DP-420 Exam Dumps and Practice Test Dumps. Q1. You are designing a Cosmos DB container that will store customers, orders, and addresses. These entities share the same tenant boundary and are frequently queried together. Which modeling technique should you consider? Create a separate Azure subscription for every entity type. Store every […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16503"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=16503"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16503\/revisions"}],"predecessor-version":[{"id":16577,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16503\/revisions\/16577"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=16503"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=16503"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=16503"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}