{"id":16510,"date":"2026-09-19T07:51:44","date_gmt":"2026-09-19T07:51:44","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=16510"},"modified":"2026-09-19T07:51:44","modified_gmt":"2026-09-19T07:51:44","slug":"microsoft-dp-420-practice-test-questions-and-exam-dumps-part11-q201-220","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/microsoft-dp-420-practice-test-questions-and-exam-dumps-part11-q201-220\/","title":{"rendered":"Microsoft DP-420 Practice Test Questions and Exam Dumps Part11 Q201-220"},"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 have a write-heavy Azure Cosmos DB container. Only the <\/b>\/customerId<\/b> and <\/b>\/createdAt<\/b> properties are used in queries. Many other large properties are never queried. What should you consider to reduce write RU consumption?<\/b><\/p>\n

    \n
  1. <\/b> Add composite indexes for every property.<\/span><\/li>\n
  2. <\/b> Enable Strong consistency.<\/span><\/li>\n
  3. <\/b> Increase the number of unique keys.<\/span><\/li>\n
  4. <\/b> Exclude unnecessary property paths from the indexing policy.<\/span><\/li>\n<\/ol>\n

    Correct Answer: 4. Exclude unnecessary property paths from the indexing policy.<\/b><\/p>\n

    Explanation:<\/b> Azure Cosmos DB automatically maintains indexes according to the container’s indexing policy. In a write-heavy workload, indexing properties that are never queried creates unnecessary index-maintenance work and can increase request-unit consumption. Excluding unused paths while keeping the properties required for filters, sorting, and other query patterns can improve write efficiency. Composite indexes should be added only when they support important query patterns. Strong consistency changes read guarantees rather than indexing overhead, and unique keys enforce data-integrity constraints. Indexing policies should always be designed around the actual balance of read and write operations.<\/span><\/p>\n

    Q2. A container has a default TTL of 3,600 seconds. One specific item must never expire. What should you configure on that item?<\/b><\/p>\n

      \n
    1. <\/b> Set the item’s TTL value so it overrides the default and prevents expiration.<\/span><\/li>\n
    2. <\/b> Remove the item’s <\/span>id<\/span>.<\/span><\/li>\n
    3. <\/b> Change the account consistency level.<\/span><\/li>\n
    4. <\/b> Add a unique key.<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. Set the item’s TTL value so it overrides the default and prevents expiration.<\/b><\/p>\n

      Explanation:<\/b> Azure Cosmos DB allows an individual item to override the container’s default time-to-live behavior. This is useful when most items share a standard retention period but specific documents must persist longer or indefinitely. Item-level TTL provides lifecycle flexibility without requiring a separate container solely for exceptional records. The item’s ID must remain present because it is required for Cosmos DB items. Consistency levels affect read guarantees, and unique keys enforce uniqueness rather than retention. TTL is an efficient alternative to custom cleanup processes for temporary data and can be customized when individual document retention differs.<\/span><\/p>\n

      Q3. Some documents in a Cosmos DB container contain <\/b>“middleName”: null<\/b>, while others do not contain the <\/b>middleName<\/b> property at all. You need to distinguish between these two cases in a query. Which capability should you use?<\/b><\/p>\n

        \n
      1. <\/b> ORDER BY<\/span><\/li>\n
      2. <\/b> TTL<\/span><\/li>\n
      3. <\/b> Type and existence functions such as <\/span>IS_NULL<\/span> and <\/span>IS_DEFINED<\/span>.<\/span><\/li>\n
      4. <\/b> Transactional Batch<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. Type and existence functions such as <\/b>IS_NULL<\/b> and <\/b>IS_DEFINED<\/b>.<\/b><\/p>\n

        Explanation:<\/b> In JSON, a property explicitly set to <\/span>null<\/span> is different from a property that is completely undefined. Cosmos DB SQL provides functions such as <\/span>IS_NULL<\/span> and <\/span>IS_DEFINED<\/span> that allow queries to distinguish between these states. This is particularly important in containers with flexible schemas, evolving document versions, or optional properties. <\/span>ORDER BY<\/span> changes result ordering, TTL manages expiration, and Transactional Batch performs atomic operations within a logical partition. Understanding the distinction between null and undefined values helps developers write more accurate queries against heterogeneous document structures.<\/span><\/p>\n

        Q4. A product document contains a <\/b>tags<\/b> array. You need to return products whose array contains the exact value <\/b>“premium”<\/b>. Which Cosmos DB SQL function is most appropriate?<\/b><\/p>\n

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

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

          Explanation:<\/b> ARRAY_CONTAINS<\/span> can test whether a Cosmos DB JSON array contains a specified value or, depending on usage, an object that matches the requested criteria. It is useful when array elements do not need to be flattened into separate result rows. A JOIN is more appropriate when you need to enumerate individual elements. <\/span>IS_NUMBER<\/span> checks value types, <\/span>DateTimeDiff<\/span> performs date calculations, and <\/span>ABS<\/span> is a mathematical function. Array-aware query functions allow applications to work naturally with denormalized JSON documents and reduce the need for application-side filtering after retrieving data.<\/span><\/p>\n

          Q5. Documents contain <\/b>startTime<\/b> and <\/b>endTime<\/b> values in supported ISO 8601 format. You need the difference between the two timestamps in minutes directly in a query. Which function should you use?<\/b><\/p>\n

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

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

            Explanation:<\/b> Cosmos DB SQL provides date and time functions that support calculations on compatible date string values. <\/span>DateTimeDiff<\/span> can calculate the difference between two timestamps using a specified interval such as minutes, hours, or days. This can be useful for duration-based filtering or projections without moving all calculations into application code. <\/span>ARRAY_LENGTH<\/span> operates on arrays, <\/span>CONTAINS<\/span> searches text, and <\/span>IS_OBJECT<\/span> tests JSON types. Query-side date calculations should still be evaluated for cost and selectivity, particularly when they are applied across large numbers of items.<\/span><\/p>\n

            Q6. A document contains a numeric <\/b>viewCount<\/b> property. You need to increase the value by 1 without reading and replacing the full document. Which operation should you use?<\/b><\/p>\n

              \n
            1. <\/b> Delete the item and recreate it.<\/span><\/li>\n
            2. <\/b> Run a cross-partition query.<\/span><\/li>\n
            3. <\/b> Replace the complete document.<\/span><\/li>\n
            4. <\/b> Use a Patch increment operation.<\/span><\/li>\n<\/ol>\n

              Correct Answer: 4. Use a Patch increment operation.<\/b><\/p>\n

              Explanation:<\/b> Azure Cosmos DB Patch operations support targeted modifications to document properties, including incrementing numeric values. Incrementing <\/span>viewCount<\/span> through Patch avoids reading and replacing the complete item when only one field changes. This can simplify application code and reduce network payload. A full replacement can still be appropriate when many fields change together, but it is unnecessary for a simple counter update. Cross-partition queries retrieve data rather than performing this targeted update. Patch is particularly valuable for status fields, counters, timestamps, and other small updates to otherwise large documents.<\/span><\/p>\n

              Q7. You are writing an SDK operation that creates an item and immediately needs to use information returned by Cosmos DB about the created resource. Which general SDK behavior should you rely on?<\/b><\/p>\n

                \n
              1. <\/b> Inspect the create operation’s response object and metadata.<\/span><\/li>\n
              2. <\/b> Delete and recreate the item to retrieve metadata.<\/span><\/li>\n
              3. <\/b> Use a backup restore.<\/span><\/li>\n
              4. <\/b> Query every partition after every create.<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. Inspect the create operation’s response object and metadata.<\/b><\/p>\n

                Explanation:<\/b> Cosmos DB SDK operations return response information that can include the created resource and useful metadata such as request charge, status, and diagnostic details depending on the SDK and operation. Applications should use this response rather than issuing unnecessary follow-up queries solely to learn whether the create succeeded or how much it cost. Deleting and recreating an item is wasteful, while backup restore is unrelated. Cross-partition queries after each create would significantly increase latency and request-unit consumption. Understanding SDK response objects is important for efficient application code and observability.<\/span><\/p>\n

                Q8. Your application runs CPU-intensive work on the same threads that perform Cosmos DB asynchronous SDK calls. Throughput is lower than expected. What should you review?<\/b><\/p>\n

                  \n
                1. <\/b> TTL settings.<\/span><\/li>\n
                2. <\/b> Client-side threading and parallelism behavior.<\/span><\/li>\n
                3. <\/b> Unique key policies.<\/span><\/li>\n
                4. <\/b> Backup mode.<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 2. Client-side threading and parallelism behavior.<\/b><\/p>\n

                  Explanation:<\/b> Cosmos DB performance depends not only on database configuration but also on how the client application schedules and executes work. Blocking or CPU-intensive processing on threads responsible for asynchronous database operations can reduce concurrency and overall throughput. Developers should review asynchronous programming patterns, client-side parallelism, thread-pool behavior, and whether the application is creating unnecessary bottlenecks. TTL, unique keys, and backup mode do not address client execution efficiency. SDK tuning should be combined with a long-lived client instance, appropriate connection mode, retry handling, and sufficient provisioned throughput.<\/span><\/p>\n

                  Q9. You need to process changes from Cosmos DB but want the application framework to automatically balance work across multiple processor instances. What should you use?<\/b><\/p>\n

                    \n
                  1. <\/b> The change feed pull model only.<\/span><\/li>\n
                  2. <\/b> A stored procedure.<\/span><\/li>\n
                  3. <\/b> A SQL UDF.<\/span><\/li>\n
                  4. <\/b> The change feed processor.<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 4. The change feed processor.<\/b><\/p>\n

                    Explanation:<\/b> The change feed processor provides a higher-level framework for consuming changes and automatically coordinating processing across multiple application instances. It uses lease information to distribute feed ranges, checkpoint progress, and rebalance work as processor instances are added or removed. The pull model gives developers more explicit control but requires more custom coordination. Stored procedures execute transactional server-side JavaScript, while UDFs are used in SQL queries. The change feed processor is usually the preferred choice when applications need scalable, managed distribution of change-feed work.<\/span><\/p>\n

                    Q10. Your application uses a custom change feed processor and the lease container is unavailable. What capability is most directly affected?<\/b><\/p>\n

                      \n
                    1. <\/b> Coordination and checkpointing of change feed processing.<\/span><\/li>\n
                    2. <\/b> Item TTL expiration.<\/span><\/li>\n
                    3. <\/b> Composite-index creation.<\/span><\/li>\n
                    4. <\/b> Global consistency configuration.<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. Coordination and checkpointing of change feed processing.<\/b><\/p>\n

                      Explanation:<\/b> The change feed processor relies on its lease container to track ownership of feed ranges, processor progress, and checkpoints. If the lease container is unavailable, processor instances cannot reliably coordinate work or persist their progress. This can interrupt scalable change processing even though the source container remains available. TTL, indexing, and account consistency do not depend on the lease container. The lease container should therefore be treated as an important operational dependency and provisioned with appropriate availability and throughput for the change feed workload.<\/span><\/p>\n

                      Q11. Your workload contains a query that filters by two equality predicates and then sorts by a third property. You want to lower RU cost. What should you evaluate?<\/b><\/p>\n

                        \n
                      1. <\/b> Disabling all indexes.<\/span><\/li>\n
                      2. <\/b> Increasing TTL.<\/span><\/li>\n
                      3. <\/b> An appropriate composite index that matches the query pattern.<\/span><\/li>\n
                      4. <\/b> Changing the backup mode.<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3. An appropriate composite index that matches the query pattern.<\/b><\/p>\n

                        Explanation:<\/b> Composite indexes can improve queries that combine multiple predicates and ordering requirements. When a frequently executed query filters on multiple fields and orders by another, a composite index aligned with the property order and sort direction can reduce execution cost. Disabling indexes would generally make the situation worse, while TTL and backup mode have no effect on query planning. Because indexes add storage and write-maintenance overhead, they should be introduced for important repeated patterns and validated by comparing query metrics and request charges before and after the change.<\/span><\/p>\n

                        Q12. You want to determine the exact RU cost of a point read during application testing. Where should you obtain the information?<\/b><\/p>\n

                          \n
                        1. <\/b> From the item’s partition-key string.<\/span><\/li>\n
                        2. <\/b> From the SDK response request-charge metadata.<\/span><\/li>\n
                        3. <\/b> From the TTL configuration.<\/span><\/li>\n
                        4. <\/b> From the failover priority.<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. From the SDK response request-charge metadata.<\/b><\/p>\n

                          Explanation:<\/b> Cosmos DB SDK responses expose request-charge information that indicates how many request units were consumed by an operation. This applies to queries and point operations and is valuable when comparing designs or estimating capacity. The partition key influences routing efficiency, but the key string itself does not report RU cost. TTL and regional failover priorities serve unrelated purposes. Capturing request charges from representative application operations is one of the most practical ways to estimate throughput requirements and identify expensive access patterns before production deployment.<\/span><\/p>\n

                          Q13. You need a data-processing workflow to archive documents to another service whenever records transition to a final state. You do not want the original write request to wait for the archive operation. Which pattern should you use?<\/b><\/p>\n

                            \n
                          1. <\/b> Process the change feed asynchronously and archive qualifying records.<\/span><\/li>\n
                          2. <\/b> Perform the archive inside every point read.<\/span><\/li>\n
                          3. <\/b> Disable indexing.<\/span><\/li>\n
                          4. <\/b> Use integrated cache as permanent archive storage.<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Process the change feed asynchronously and archive qualifying records.<\/b><\/p>\n

                            Explanation:<\/b> Change feed processing allows archival logic to run after source changes are committed, keeping the original transactional request focused and low latency. A processor can inspect changed documents, identify records that reached the final state, and copy them to the archive destination. The workflow should account for retries and idempotency so records are not archived incorrectly multiple times. Reads should not trigger archival behavior, and integrated cache is not durable archival storage. Asynchronous change-driven integration is a common Cosmos DB architecture pattern.<\/span><\/p>\n

                            Q14. You need to ensure that a downstream reporting container reflects changes made to a source container, but temporary delays are acceptable. What consistency model does this architecture represent at the application level?<\/b><\/p>\n

                              \n
                            1. <\/b> Synchronous distributed transaction.<\/span><\/li>\n
                            2. <\/b> Eventual consistency between the source and derived projection.<\/span><\/li>\n
                            3. <\/b> Strong consistency across separate applications by default.<\/span><\/li>\n
                            4. <\/b> NoSQL schema validation.<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2. Eventual consistency between the source and derived projection.<\/b><\/p>\n

                              Explanation:<\/b> When a materialized projection is updated asynchronously from the change feed, there is a period after the source write during which the derived container may not yet contain the newest state. This is an application-level eventual-consistency pattern. It is common in scalable distributed systems because it separates transactional operations from downstream reporting or denormalization work. This architectural concept is distinct from the Cosmos DB account consistency level used for reads. Designers should make sure users and downstream systems understand the expected delay and that change processing is monitored for backlog.<\/span><\/p>\n

                              Q15. You need to expose Cosmos DB data to Azure AI Search and keep the search index updated as source data changes. Which design is appropriate?<\/b><\/p>\n

                                \n
                              1. <\/b> Disable the Cosmos DB partition key.<\/span><\/li>\n
                              2. <\/b> Use periodic backup as the search index.<\/span><\/li>\n
                              3. <\/b> Use integrated cache as the search engine.<\/span><\/li>\n
                              4. <\/b> Integrate Cosmos DB with Azure AI Search using a supported indexing approach.<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 4. Integrate Cosmos DB with Azure AI Search using a supported indexing approach.<\/b><\/p>\n

                                Explanation:<\/b> Azure AI Search provides specialized indexing and full-text search capabilities that complement Cosmos DB’s role as an operational database. A supported integration can populate and update a dedicated search index from Cosmos DB data. This enables capabilities such as search relevance and text-oriented lookup without forcing the transactional database to act as a full search engine. Partition keys, backup copies, and integrated cache do not replace a search index. The solution should account for update frequency, index schema, source changes, and acceptable synchronization delay.<\/span><\/p>\n

                                Q16. You need a Spark pipeline that only analyzes Cosmos DB data and should avoid consuming transactional RU\/s for large analytical scans. Which source should Spark use when available?<\/b><\/p>\n

                                  \n
                                1. <\/b> The transactional store through point reads only.<\/span><\/li>\n
                                2. <\/b> The analytical store.<\/span><\/li>\n
                                3. <\/b> The account backup files.<\/span><\/li>\n
                                4. <\/b> The lease container.<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 2. The analytical store.<\/b><\/p>\n

                                  Explanation:<\/b> The analytical store provides a column-oriented representation designed for analytical workloads and helps separate large-scale analytics from the request-unit consumption of the transactional store. Spark-based analysis can use this representation when the architecture supports it, making it better suited for broad scans and analytical transformations. The transactional store remains the correct source when the workload requires operational reads and writes. Backup files and lease containers are not analytical sources. Choosing the correct store helps avoid unnecessary pressure on production transactional workloads.<\/span><\/p>\n

                                  Q17. An application must remain available for reads if its nearest Azure region fails. The Cosmos DB account already has multiple read regions. What else should the application configure?<\/b><\/p>\n

                                    \n
                                  1. <\/b> A suitable SDK region preference and failover behavior.<\/span><\/li>\n
                                  2. <\/b> TTL on every item.<\/span><\/li>\n
                                  3. <\/b> One constant partition key.<\/span><\/li>\n
                                  4. <\/b> A UDF for every query.<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. A suitable SDK region preference and failover behavior.<\/b><\/p>\n

                                    Explanation:<\/b> Adding multiple Cosmos DB regions provides the service-side foundation for regional availability, but the application should also be configured to use those regions appropriately. SDK preferred-region settings help clients choose low-latency regions and fail over to another healthy replica when required. TTL, UDFs, and constant partition keys do not improve regional routing. Resilience testing should verify both account configuration and application behavior because a database may be regionally resilient while an application remains tied to one endpoint or deployment assumption.<\/span><\/p>\n

                                    Q18. Your organization requires the strongest possible read consistency so clients never observe stale committed data. Which level should you select if supported by the account’s regional configuration?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Eventual.<\/span><\/li>\n
                                    2. <\/b> Strong.<\/span><\/li>\n
                                    3. <\/b> Consistent prefix.<\/span><\/li>\n
                                    4. <\/b> Session.<\/span><\/li>\n<\/ol>\n

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

                                      Explanation:<\/b> Strong consistency guarantees that reads return the most recent committed version of data, providing linearizable behavior from the application’s perspective. This is the strictest Cosmos DB consistency level and can have tradeoffs in latency, throughput, availability, and regional configuration. Session consistency is often sufficient for interactive applications, while eventual and consistent-prefix levels allow stale reads under defined semantics. Consistency should be chosen according to application correctness requirements rather than by automatically selecting the strongest level because stronger guarantees can affect performance and global distribution options.<\/span><\/p>\n

                                      Q19. Monitoring shows a container’s data is evenly distributed across partitions, but one partition still receives far more requests than the others. What does this indicate?<\/b><\/p>\n

                                        \n
                                      1. <\/b> A throughput-distribution hotspot caused by skewed access patterns.<\/span><\/li>\n
                                      2. <\/b> Backup corruption.<\/span><\/li>\n
                                      3. <\/b> A unique-key failure.<\/span><\/li>\n
                                      4. <\/b> TTL malfunction.<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. A throughput-distribution hotspot caused by skewed access patterns.<\/b><\/p>\n

                                        Explanation:<\/b> Balanced data distribution does not guarantee balanced request distribution. If users disproportionately access one partition-key value, that partition can become hot even though storage is evenly spread. Monitoring both data distribution and throughput distribution is therefore essential. The solution may involve revisiting access patterns, partition-key design, caching, data duplication, or workload routing. Backup, unique keys, and TTL do not explain uneven request pressure. Production workloads should be monitored because actual traffic patterns can expose hotspots that were not obvious from data size alone.<\/span><\/p>\n

                                        Q20. You need to detect unusual spikes in HTTP 429 throttling and automatically notify an operations team. Which solution should you configure?<\/b><\/p>\n

                                          \n
                                        1. <\/b> A unique key.<\/span><\/li>\n
                                        2. <\/b> TTL.<\/span><\/li>\n
                                        3. <\/b> Azure Monitor metrics with an alert rule and action group.<\/span><\/li>\n
                                        4. <\/b> A stored procedure.<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. Azure Monitor metrics with an alert rule and action group.<\/b><\/p>\n

                                          Explanation:<\/b> Azure Monitor can track Cosmos DB metrics related to throttling and other operational conditions. An alert rule can evaluate those metrics over a specified time window, and an action group can notify the operations team through supported channels or trigger automation. Unique keys enforce data integrity, TTL controls document expiration, and stored procedures execute server-side transactional logic. Proactive alerts are essential for identifying capacity issues, hot partitions, and unexpected traffic changes before sustained throttling significantly affects application performance.<\/span><\/p>\n

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

                                            View Full Microsoft DP-420 Exam Dumps and Practice Test Dumps. Q1. You have a write-heavy Azure Cosmos DB container. Only the \/customerId and \/createdAt properties are used in queries. Many other large properties are never queried. What should you consider to reduce write RU consumption? Add composite indexes for every property. Enable Strong consistency. […]<\/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\/16510"}],"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=16510"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16510\/revisions"}],"predecessor-version":[{"id":16570,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16510\/revisions\/16570"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=16510"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=16510"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=16510"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}