{"id":16516,"date":"2026-09-19T07:50:17","date_gmt":"2026-09-19T07:50:17","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=16516"},"modified":"2026-09-19T07:50:17","modified_gmt":"2026-09-19T07:50:17","slug":"microsoft-dp-420-practice-test-questions-and-exam-dumps-part17-q321-340","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/microsoft-dp-420-practice-test-questions-and-exam-dumps-part17-q321-340\/","title":{"rendered":"Microsoft DP-420 Practice Test Questions and Exam Dumps Part17 Q321-340"},"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 an Azure Cosmos DB for NoSQL container for hotel reservations. Most operations retrieve reservations by hotel and reservation year. Individual hotels can generate extremely large amounts of historical data. Which partition-key approach should you consider?<\/b><\/p>\n

    \n
  1. <\/b> Use <\/span>\/reservationStatus<\/span> only.<\/span><\/li>\n
  2. <\/b> Use one fixed partition-key value for all hotels.<\/span><\/li>\n
  3. <\/b> Use <\/span>\/guestName<\/span> only.<\/span><\/li>\n
  4. <\/b> Use a hierarchical partition key such as <\/span>\/hotelId<\/span> followed by <\/span>\/reservationYear<\/span>.<\/span><\/li>\n<\/ol>\n

    Correct Answer: 4. Use a hierarchical partition key such as <\/b>\/hotelId<\/b> followed by <\/b>\/reservationYear<\/b>.<\/b><\/p>\n

    Explanation:<\/b> A hierarchical partition key can align with hotel-based access while further distributing the data of high-volume hotels by year. This helps preserve efficient routing for requests that begin with hotel identity while reducing the risk that one hotel becomes excessively large or hot. Reservation status usually has low cardinality, while a constant key would prevent effective horizontal scaling. Guest name may have many values but does not match the primary access pattern. Good Cosmos DB partition design must consider data growth, logical-partition limits, query routing, and request-unit distribution together.<\/span><\/p>\n

    Q2. Your application needs to create an item only if another item with the same <\/b>id<\/b> and partition key does not already exist. Which SDK operation should you use?<\/b><\/p>\n

      \n
    1. <\/b> Upsert Item.<\/span><\/li>\n
    2. <\/b> Create Item.<\/span><\/li>\n
    3. <\/b> Patch Item.<\/span><\/li>\n
    4. <\/b> Replace Item.<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2. Create Item.<\/b><\/p>\n

      Explanation:<\/b> Create Item is appropriate when the application wants insertion semantics and must fail if the item identity already exists within the same logical partition. Upsert differs because it creates a new item when none exists but replaces the existing item when the same identity is found. Patch modifies selected fields of an existing document, while Replace rewrites an existing item. Choosing the correct SDK operation is important because it determines how duplicate identities are handled and whether an existing record can be overwritten unintentionally.<\/span><\/p>\n

      Q3. You need a query to determine whether a JSON document contains an array with exactly five elements. Which Cosmos DB SQL capability should you use?<\/b><\/p>\n

        \n
      1. <\/b> ARRAY_LENGTH<\/span><\/li>\n
      2. <\/b> IS_STRING<\/span><\/li>\n
      3. <\/b> DateTimeDiff<\/span><\/li>\n
      4. <\/b> VectorDistance<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. <\/b>ARRAY_LENGTH<\/b><\/p>\n

        Explanation:<\/b> ARRAY_LENGTH<\/span> returns the number of elements in a JSON array and can be used in projections or predicates. For example, a query can filter documents where <\/span>ARRAY_LENGTH(c.items) = 5<\/span>. This is useful when application data is modeled using embedded arrays. <\/span>IS_STRING<\/span> checks a value’s type, <\/span>DateTimeDiff<\/span> calculates differences between dates, and <\/span>VectorDistance<\/span> performs vector similarity comparisons. Cosmos DB SQL includes many JSON-aware functions that let applications query nested structures directly instead of retrieving entire documents and processing them in application code.<\/span><\/p>\n

        Q4. You need multiple application instances to process the same Cosmos DB change feed workload without duplicating ownership of feed ranges. Which resource coordinates this processing?<\/b><\/p>\n

          \n
        1. <\/b> Analytical store.<\/span><\/li>\n
        2. <\/b> Integrated cache.<\/span><\/li>\n
        3. <\/b> Lease container.<\/span><\/li>\n
        4. <\/b> Unique key policy.<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. Lease container.<\/b><\/p>\n

          Explanation:<\/b> The change feed processor uses a lease container to coordinate feed-range ownership, checkpoint progress, and load balancing among processor instances. Each processor instance acquires leases for portions of the feed so that the workload is distributed rather than unnecessarily duplicated. As processor instances scale in or out, leases can be rebalanced. Analytical store supports analytics, integrated cache reduces eligible read costs, and unique keys enforce document constraints. The lease container is therefore an important operational dependency when using the change feed processor framework.<\/span><\/p>\n

          Q5. You need to update a document’s <\/b>inventory<\/b> property by subtracting 1 without sending the entire document from the application. Which operation should you use?<\/b><\/p>\n

            \n
          1. <\/b> Replace the full document.<\/span><\/li>\n
          2. <\/b> Patch with an increment operation using a negative value.<\/span><\/li>\n
          3. <\/b> Delete and recreate the document.<\/span><\/li>\n
          4. <\/b> Execute a cross-partition query.<\/span><\/li>\n<\/ol>\n

            Correct Answer: 2. Patch with an increment operation using a negative value.<\/b><\/p>\n

            Explanation:<\/b> Patch supports targeted modifications to document properties, including numeric increment operations. Supplying a negative increment value can decrease the inventory count without replacing the full item. This can reduce network payload and simplify application logic, especially for large documents where only one numeric field changes frequently. Replacing the entire document is valid but less targeted. Delete-and-create introduces unnecessary operations and can affect metadata or concurrency behavior. A cross-partition query retrieves data and does not provide the required efficient partial update.<\/span><\/p>\n

            Q6. You need an application to process every intermediate update to a document, not just the latest version, and also detect deletion events. Which change feed mode should you select?<\/b><\/p>\n

              \n
            1. <\/b> Latest version mode.<\/span><\/li>\n
            2. <\/b> Integrated cache mode.<\/span><\/li>\n
            3. <\/b> Pull mode without version history.<\/span><\/li>\n
            4. <\/b> All versions and deletes mode.<\/span><\/li>\n<\/ol>\n

              Correct Answer: 4. All versions and deletes mode.<\/b><\/p>\n

              Explanation:<\/b> All versions and deletes mode is intended for workloads that need richer history than the default latest-version change feed. It can expose intermediate item versions and deletion information within the supported retention model, making it appropriate for auditing, synchronization, and certain event-history scenarios. Latest version mode focuses on the newest state of changed documents and may not surface every intermediate update. Integrated cache is unrelated, while pull mode describes how a consumer accesses the feed rather than whether complete version history is available.<\/span><\/p>\n

              Q7. Your application performs many reads of documents that are identified by <\/b>id<\/b> and partition key. Which factor usually makes these reads particularly efficient?<\/b><\/p>\n

                \n
              1. <\/b> They can use point-read operations.<\/span><\/li>\n
              2. <\/b> They always use a full-text index.<\/span><\/li>\n
              3. <\/b> They require analytical store.<\/span><\/li>\n
              4. <\/b> They automatically use a stored procedure.<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. They can use point-read operations.<\/b><\/p>\n

                Explanation:<\/b> When an application’s data model makes both the item ID and partition-key value available, the SDK can issue point reads. Point reads avoid SQL query processing and are typically among the lowest-cost, lowest-latency Cosmos DB read operations. Full-text indexes are for text search, analytical store is for analytics, and stored procedures are not required for direct item retrieval. Designing APIs and references so the partition key is available alongside the item ID can significantly improve efficiency for frequently accessed records.<\/span><\/p>\n

                Q8. Your Cosmos DB account contains a container with a large <\/b>rawMessage<\/b> property that is never filtered, sorted, or searched. The workload is write-heavy. What should you consider?<\/b><\/p>\n

                  \n
                1. <\/b> Add several composite indexes to <\/span>rawMessage<\/span>.<\/span><\/li>\n
                2. <\/b> Make <\/span>rawMessage<\/span> the partition key.<\/span><\/li>\n
                3. <\/b> Exclude the <\/span>rawMessage<\/span> path from indexing.<\/span><\/li>\n
                4. <\/b> Enable Strong consistency.<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. Exclude the <\/b>rawMessage<\/b> path from indexing.<\/b><\/p>\n

                  Explanation:<\/b> Excluding unused paths from indexing can reduce the index-maintenance overhead associated with writes. Large high-cardinality properties such as raw messages, diagnostic payloads, or embedded audit details can increase write cost if indexed despite never participating in queries. Composite indexes would increase indexing work rather than reduce it. Changing the partition key is a separate modeling decision, and Strong consistency affects read guarantees. Indexing should reflect actual query patterns so the application receives needed read performance without paying unnecessary write and storage costs.<\/span><\/p>\n

                  Q9. Your globally distributed application must accept writes close to users in North America, Europe, and Asia. Which Cosmos DB capability should you enable?<\/b><\/p>\n

                    \n
                  1. <\/b> Integrated cache.<\/span><\/li>\n
                  2. <\/b> Periodic backup.<\/span><\/li>\n
                  3. <\/b> One read region only.<\/span><\/li>\n
                  4. <\/b> Multi-region writes.<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 4. Multi-region writes.<\/b><\/p>\n

                    Explanation:<\/b> Multi-region writes allow more than one Azure region to accept write operations, enabling geographically distributed applications to write closer to their users and continue writing if one region becomes unavailable. This architecture can reduce write latency and improve availability but introduces the possibility of concurrent write conflicts. The design must therefore include an appropriate conflict-resolution strategy. Integrated cache improves eligible reads, while backup and single-region configurations do not provide distributed write capabilities.<\/span><\/p>\n

                    Q10. You need to calculate the number of hours between two timestamp properties inside a Cosmos DB SQL query. Which function is appropriate?<\/b><\/p>\n

                      \n
                    1. <\/b> DateTimeDiff<\/span><\/li>\n
                    2. <\/b> ARRAY_CONTAINS<\/span><\/li>\n
                    3. <\/b> IS_OBJECT<\/span><\/li>\n
                    4. <\/b> VectorDistance<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. <\/b>DateTimeDiff<\/b><\/p>\n

                      Explanation:<\/b> DateTimeDiff<\/span> can calculate the difference between compatible date-time values using a specified unit such as seconds, minutes, hours, or days. This is useful when duration logic belongs naturally in the query, such as filtering records that remained open for more than a certain number of hours. <\/span>ARRAY_CONTAINS<\/span> works with arrays, <\/span>IS_OBJECT<\/span> checks JSON types, and <\/span>VectorDistance<\/span> supports vector similarity. Query-side date calculations can simplify applications, but their RU cost should still be measured for large workloads.<\/span><\/p>\n

                      Q11. A container’s indexing policy is changed substantially in production. What should you monitor while Cosmos DB applies the new policy?<\/b><\/p>\n

                        \n
                      1. <\/b> Only the account’s region count.<\/span><\/li>\n
                      2. <\/b> Index transformation progress and workload performance.<\/span><\/li>\n
                      3. <\/b> Only the TTL value.<\/span><\/li>\n
                      4. <\/b> The number of session tokens.<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2. Index transformation progress and workload performance.<\/b><\/p>\n

                        Explanation:<\/b> Significant indexing changes can trigger an index transformation so existing data becomes compatible with the new indexing configuration. During this period, teams should monitor transformation progress as well as request-unit consumption, query behavior, and write performance. Indexes that improve reads may add write overhead, so both sides of the workload should be validated. Region count, TTL, and session-token details do not describe index transformation health. Index-policy changes should be treated as controlled production configuration changes and tested before wide deployment.<\/span><\/p>\n

                        Q12. You need to store embedding vectors and perform similarity searches directly inside Cosmos DB. What is required?<\/b><\/p>\n

                          \n
                        1. <\/b> A full-text policy only.<\/span><\/li>\n
                        2. <\/b> TTL.<\/span><\/li>\n
                        3. <\/b> A vector embedding policy and suitable vector index.<\/span><\/li>\n
                        4. <\/b> A unique key on the embedding array.<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3. A vector embedding policy and suitable vector index.<\/b><\/p>\n

                          Explanation:<\/b> Cosmos DB vector search requires configuration describing the embedding path and its characteristics, such as dimensions, type, and distance function. A suitable vector index then accelerates similarity searches. This enables scenarios such as semantic search, recommendations, and retrieval-augmented generation without moving the vectors to a separate database. Full-text policies address text search, TTL controls retention, and unique keys enforce constraints. The embedding model used by the application must produce vectors that match the configured vector dimensions and distance semantics.<\/span><\/p>\n

                          Q13. You need to create a search experience that combines semantic similarity with exact keyword relevance. Which design should you use?<\/b><\/p>\n

                            \n
                          1. <\/b> Hybrid search using vector and full-text capabilities.<\/span><\/li>\n
                          2. <\/b> TTL plus a unique key.<\/span><\/li>\n
                          3. <\/b> Integrated cache only.<\/span><\/li>\n
                          4. <\/b> Change feed leases.<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Hybrid search using vector and full-text capabilities.<\/b><\/p>\n

                            Explanation:<\/b> Hybrid search combines vector similarity with lexical or full-text relevance so applications can benefit from both semantic meaning and exact textual matches. This can improve retrieval quality for product discovery, knowledge bases, and RAG applications. Vector search is useful when concepts are similar even if wording differs, while full-text search captures keyword and language-oriented relevance. TTL, unique keys, cache, and leases solve unrelated lifecycle, integrity, performance, and change-processing concerns.<\/span><\/p>\n

                            Q14. You need Cosmos DB changes to automatically invoke lightweight serverless business logic. Which Azure integration is most appropriate?<\/b><\/p>\n

                              \n
                            1. <\/b> Azure Bastion.<\/span><\/li>\n
                            2. <\/b> Azure Monitor Workbook.<\/span><\/li>\n
                            3. <\/b> Azure DNS.<\/span><\/li>\n
                            4. <\/b> Azure Functions with a Cosmos DB trigger.<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 4. Azure Functions with a Cosmos DB trigger.<\/b><\/p>\n

                              Explanation:<\/b> The Azure Functions Cosmos DB trigger uses the change feed to invoke function code when new or updated items are available. It is suitable for serverless event-driven workflows such as notifications, integrations, aggregation, and denormalized projections. Bastion provides secure VM access, Monitor Workbooks provide observability, and DNS handles name resolution. Trigger-based code should be idempotent because retries may occur, and processor lag should be monitored when downstream freshness is important.<\/span><\/p>\n

                              Q15. A Spark workload needs direct read and write access to the Cosmos DB transactional store. Which integration should you use?<\/b><\/p>\n

                                \n
                              1. <\/b> Analytical store only.<\/span><\/li>\n
                              2. <\/b> Azure Cosmos DB Spark connector.<\/span><\/li>\n
                              3. <\/b> Azure Monitor.<\/span><\/li>\n
                              4. <\/b> Periodic backup.<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. Azure Cosmos DB Spark connector.<\/b><\/p>\n

                                Explanation:<\/b> The Cosmos DB Spark connector allows distributed Spark jobs to interact directly with the transactional store for supported reads and writes. It is appropriate for transformations, migrations, or enrichment pipelines where Spark processing must persist results back into Cosmos DB. Analytical store is better suited for analytics that should be isolated from transactional RU usage. Azure Monitor provides observability, and backup provides recovery. Spark jobs should be tuned carefully because direct transactional-store access consumes request units and can affect application workloads.<\/span><\/p>\n

                                Q16. Your reporting workload performs very large analytical scans over operational Cosmos DB data. You want to minimize impact on transactional RU consumption. What should you use?<\/b><\/p>\n

                                  \n
                                1. <\/b> Strong consistency.<\/span><\/li>\n
                                2. <\/b> Transactional Batch.<\/span><\/li>\n
                                3. <\/b> Analytical store.<\/span><\/li>\n
                                4. <\/b> Integrated cache only.<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Analytical store.<\/b><\/p>\n

                                  Explanation:<\/b> Analytical store provides a column-oriented representation of Cosmos DB data intended for large-scale analytics. It allows analytical tools to scan data without placing the same pressure on the transactional request-unit workload. This is useful for reporting, Spark analysis, and other read-intensive scenarios. Integrated cache helps repeated operational reads but is not a replacement for a dedicated analytical representation. Strong consistency and Transactional Batch address different correctness and transaction requirements.<\/span><\/p>\n

                                  Q17. You need to know whether a change feed processor is getting behind the incoming write rate. Which feature should you use?<\/b><\/p>\n

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

                                    Correct Answer: 4. Change feed estimator.<\/b><\/p>\n

                                    Explanation:<\/b> The change feed estimator reports an estimate of pending work for a change feed processor. A growing backlog indicates that changes are arriving faster than the processors are handling them. This can guide scale-out decisions or reveal that more Cosmos DB throughput is needed for downstream processing. TTL, cache, and unique keys do not provide processor-lag visibility. Monitoring change feed lag is especially important when projections or downstream integrations need to stay close to real time.<\/span><\/p>\n

                                    Q18. You need to recover a Cosmos DB container to the state it had immediately before a faulty deployment. The account already uses continuous backup. What should you identify?<\/b><\/p>\n

                                      \n
                                    1. <\/b> The current continuation token.<\/span><\/li>\n
                                    2. <\/b> A valid point-in-time restore timestamp before the deployment.<\/span><\/li>\n
                                    3. <\/b> The latest session token.<\/span><\/li>\n
                                    4. <\/b> The integrated-cache age.<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. A valid point-in-time restore timestamp before the deployment.<\/b><\/p>\n

                                      Explanation:<\/b> Continuous backup supports point-in-time restore within its retention window. To recover from a bad deployment, administrators should determine when the damaging changes began and choose a restore point just before that time. The resource scope and restored data should then be validated before applications resume using it. Continuation tokens, session tokens, and cache settings do not describe recovery state. Restore procedures should be tested ahead of incidents so operators can quickly identify timestamps and affected resources.<\/span><\/p>\n

                                      Q19. You need an automated warning when one partition repeatedly approaches its available RU capacity. What should you configure?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Azure Monitor alerts based on partition-level throughput metrics.<\/span><\/li>\n
                                      2. <\/b> A SQL UDF.<\/span><\/li>\n
                                      3. <\/b> TTL.<\/span><\/li>\n
                                      4. <\/b> A unique key policy.<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. Azure Monitor alerts based on partition-level throughput metrics.<\/b><\/p>\n

                                        Explanation:<\/b> Partition-level throughput metrics can reveal hot partitions that account-level averages may hide. Azure Monitor can evaluate these metrics and trigger alerts when a partition remains near capacity for a defined period. This allows operations teams to investigate partition-key skew, high-volume tenants, or sudden traffic changes before sustained throttling impacts users. UDFs, TTL, and unique keys solve different query, retention, and integrity needs. Effective Cosmos DB monitoring should include both aggregate and partition-level indicators.<\/span><\/p>\n

                                        Q20. You need detailed Cosmos DB resource logs to be searchable alongside application telemetry using Kusto Query Language. What should you configure?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Integrated cache.<\/span><\/li>\n
                                        2. <\/b> TTL.<\/span><\/li>\n
                                        3. <\/b> Azure Monitor diagnostic settings that send logs to a Log Analytics workspace.<\/span><\/li>\n
                                        4. <\/b> A composite index.<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. Azure Monitor diagnostic settings that send logs to a Log Analytics workspace.<\/b><\/p>\n

                                          Explanation:<\/b> Diagnostic settings can route Cosmos DB resource logs into a Log Analytics workspace, where Kusto Query Language can be used for troubleshooting, auditing, security investigations, and correlation with application telemetry. This centralized approach is much more effective than reviewing isolated signals from individual systems. Integrated cache optimizes reads, TTL controls expiration, and composite indexes optimize queries. Production systems should retain logs according to operational and compliance requirements and include useful correlation information in application telemetry.<\/span><\/p>\n

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

                                            View Full Microsoft DP-420 Exam Dumps and Practice Test Dumps. Q1. You are designing an Azure Cosmos DB for NoSQL container for hotel reservations. Most operations retrieve reservations by hotel and reservation year. Individual hotels can generate extremely large amounts of historical data. Which partition-key approach should you consider? Use \/reservationStatus only. Use one […]<\/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\/16516"}],"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=16516"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16516\/revisions"}],"predecessor-version":[{"id":16564,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16516\/revisions\/16564"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=16516"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=16516"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=16516"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}