{"id":18163,"date":"2026-09-22T05:49:16","date_gmt":"2026-09-22T05:49:16","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18163"},"modified":"2026-09-22T05:49:16","modified_gmt":"2026-09-22T05:49:16","slug":"cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part1-q1-20","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part1-q1-20\/","title":{"rendered":"Cisco CCNP Automation 350-901 Practice Test Questions and Exam Dumps Part1 Q1-20"},"content":{"rendered":"

View Full <\/b>Cisco CCNP Automation 350-901 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Q1. A Python application consumes a REST API that limits clients to 100 requests per minute. The API returns HTTP 429 when the limit is exceeded. What should the application do?<\/b><\/p>\n

    \n
  1. <\/b> Immediately repeat requests in a tight loop<\/span>
    \n<\/span>2.<\/b> Respect rate-limit information and retry after an appropriate delay<\/span>
    \n<\/span>3.<\/b> Treat HTTP 429 as a successful response<\/span>
    \n<\/span>4.<\/b> Disable error handling<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2. Respect rate-limit information and retry after an appropriate delay<\/b><\/p>\n

    Explanation:<\/b> HTTP 429 indicates that the client has exceeded an API’s permitted request rate. Robust consumer code should detect this status and delay subsequent requests according to the API’s documented rate-limit behavior, including a <\/span>Retry-After<\/span> header when provided. Exponential backoff can also be useful when explicit timing information is unavailable. Repeated immediate requests can worsen throttling and create unnecessary load. The application should also place an upper bound on retries and report persistent failures appropriately. Handling API rate limits and timeouts is explicitly included in the current DEVCOR Using APIs domain.<\/span><\/p>\n

    Q2. A development team needs a database for highly connected data in which relationships between users, devices, applications, and locations are frequently traversed. Which database type is most appropriate?<\/b><\/p>\n

      \n
    1. <\/b> Time-series database<\/span>
      \n<\/span>2.<\/b> Columnar database<\/span>
      \n<\/span>3.<\/b> Key-value cache only<\/span>
      \n<\/span>4.<\/b> Graph database<\/span><\/li>\n<\/ol>\n

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

      Explanation:<\/b> Graph databases are designed around entities and the relationships connecting them. They are particularly useful when application queries frequently traverse relationships, such as determining which users access which devices, which applications depend on other services, or how objects are connected through multiple hops. Relational databases can model relationships but may require complex joins for highly connected datasets. Time-series databases specialize in timestamped observations, while columnar stores are optimized for particular analytical workloads. The current DEVCOR blueprint expects candidates to evaluate relational, document, graph, columnar, and time-series databases according to application requirements.<\/span><\/p>\n

      Q3. A developer needs to undo a specific Git commit that has already been pushed to a shared repository without rewriting project history. Which Git command should be used?<\/b><\/p>\n

        \n
      1. <\/b> git revert<\/span>
        \n<\/span>2.<\/b> git reset –hard<\/span>
        \n<\/span>3.<\/b> git checkout — .<\/span>
        \n<\/span>4.<\/b> git init<\/span><\/li>\n<\/ol>\n

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

        Explanation:<\/b> git revert<\/span> creates a new commit that reverses the changes introduced by a previous commit. This makes it appropriate for shared repositories because existing commit history remains intact and collaborators do not need to reconcile rewritten history. <\/span>git reset –hard<\/span> moves a branch pointer and changes the local working state; using it to rewrite already shared history can disrupt other developers. <\/span>git checkout — .<\/span> affects working files rather than safely reversing a published commit. Advanced Git operations including merge, conflict resolution, reset, checkout, and revert are explicitly included in the DEVCOR blueprint.<\/span><\/p>\n

        Q4. A web service must continue serving clients if one application instance fails. Which design provides the strongest improvement in availability?<\/b><\/p>\n

          \n
        1. <\/b> Deploy one larger application server<\/span>
          \n<\/span>2.<\/b> Disable health checks to reduce traffic<\/span>
          \n<\/span>3.<\/b> Run multiple application instances behind a load balancer with health monitoring<\/span>
          \n<\/span>4.<\/b> Store all application state only in local memory on one instance<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. Run multiple application instances behind a load balancer with health monitoring<\/b><\/p>\n

          Explanation:<\/b> Multiple application instances remove the dependency on a single process or host, while a load balancer distributes requests and avoids unhealthy instances based on health monitoring. For effective resiliency, shared or persistent state should also be externalized so a client can be served by another instance when one fails. A single larger server remains a single point of failure. Disabling health monitoring can direct clients to failed instances. The DEVCOR software design domain expects candidates to evaluate applications for high availability and resiliency across on-premises, hybrid, and cloud environments.<\/span><\/p>\n

          Q5. An application retrieves a resource through an HTTP API. The server returns a strong ETag. How can the client reduce unnecessary data transfer on later requests?<\/b><\/p>\n

            \n
          1. <\/b> Always request the full object again<\/span>
            \n<\/span>2.<\/b> Replace GET with POST<\/span>
            \n<\/span>3.<\/b> Disable caching headers<\/span>
            \n<\/span>4.<\/b> Send a conditional request using the ETag value<\/span><\/li>\n<\/ol>\n

            Correct Answer: 4. Send a conditional request using the ETag value<\/b><\/p>\n

            Explanation:<\/b> ETags allow HTTP clients to make conditional requests and avoid downloading unchanged content. The client can store the ETag returned with the previous representation and later send it with an <\/span>If-None-Match<\/span> header. If the resource has not changed, the server can respond with HTTP 304 Not Modified rather than returning the entire representation again. This reduces bandwidth consumption and API-processing overhead. Replacing GET with POST is not an appropriate caching strategy. HTTP cache controls and ways to optimize API usage are specifically included in the current DEVCOR API objectives.<\/span><\/p>\n

            Q6. A REST API returns only 50 objects per response and includes a link to the next result page. What should a consumer application do to obtain every object?<\/b><\/p>\n

              \n
            1. <\/b> Assume the first 50 results represent the complete dataset<\/span>
              \n<\/span>2.<\/b> Follow the API’s pagination mechanism until no additional page remains<\/span>
              \n<\/span>3.<\/b> Repeat the first request indefinitely<\/span>
              \n<\/span>4.<\/b> Increase the HTTP timeout and ignore pagination<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. Follow the API’s pagination mechanism until no additional page remains<\/b><\/p>\n

              Explanation:<\/b> APIs commonly paginate large result sets to protect server performance and limit response size. Consumer code must process the current page and follow the documented continuation mechanism, which might use page numbers, cursors, tokens, offsets, or links. The workflow should stop only when the API indicates that no additional results remain. Failing to process pagination can silently produce incomplete data and incorrect automation decisions. The current DEVCOR blueprint explicitly requires candidates to construct applications that consume REST APIs supporting pagination.<\/span><\/p>\n

              Q7. Which architectural pattern is most appropriate when independently deployable business capabilities must scale separately and communicate through well-defined interfaces?<\/b><\/p>\n

                \n
              1. <\/b> Microservices architecture<\/span>
                \n<\/span>2.<\/b> One tightly coupled monolithic executable only<\/span>
                \n<\/span>3.<\/b> Single shared global state without APIs<\/span>
                \n<\/span>4.<\/b> Client-side application with no backend services<\/span><\/li>\n<\/ol>\n

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

                Explanation:<\/b> Microservices separate an application into smaller independently deployable services aligned to distinct capabilities. Each service can be scaled, updated, and operated separately, provided interfaces and data ownership are designed carefully. The architecture can improve modularity and deployment flexibility but introduces complexity around networking, observability, data consistency, service discovery, and failure handling. A monolith can be appropriate for simpler applications but does not inherently provide independent service deployment. DEVCOR expects candidates to understand monolithic, service-oriented, microservices, and event-driven architecture patterns.<\/span><\/p>\n

                Q8. A developer is documenting how a client, API gateway, application service, and database interact during a login request. Which diagram best shows messages exchanged over time between these components?<\/b><\/p>\n

                  \n
                1. <\/b> Pie chart<\/span>
                  \n<\/span>2.<\/b> Entity inventory<\/span>
                  \n<\/span>3.<\/b> Sequence diagram<\/span>
                  \n<\/span>4.<\/b> VLAN table<\/span><\/li>\n<\/ol>\n

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

                  Explanation:<\/b> A sequence diagram represents participants and the order in which messages pass among them over time. It is well suited to application and API design because developers can show a client request, API gateway validation, backend service calls, database queries, and responses in chronological order. Sequence diagrams help teams identify dependencies, failure points, and expected control flow before implementation. They can also make API interactions easier to discuss across development and operations teams. Constructing a sequence diagram that includes API calls is explicitly listed in the current DEVCOR exam topics.<\/span><\/p>\n

                  Q9. During the OAuth 2.0 authorization code flow, what does the client application receive after the resource owner approves access and the authorization server redirects the browser back to the client?<\/b><\/p>\n

                    \n
                  1. <\/b> The user’s permanent password<\/span>
                    \n<\/span>2.<\/b> An authorization code that can be exchanged for tokens<\/span>
                    \n<\/span>3.<\/b> The API server’s private key<\/span>
                    \n<\/span>4.<\/b> An unlimited administrator token<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 2. An authorization code that can be exchanged for tokens<\/b><\/p>\n

                    Explanation:<\/b> In the three-legged OAuth authorization code flow, the user authenticates to the authorization server and approves the requested permissions. The authorization server then redirects the user agent back to the client application with an authorization code. The client exchanges this short-lived code at the token endpoint for an access token and, depending on the design, possibly a refresh token. The client should not receive the user’s password. DEVCOR explicitly requires knowledge of the OAuth 2.0 three-legged authorization code grant flow as part of the Using APIs domain.<\/span><\/p>\n

                    Q10. A backend application records request latency, errors, dependency calls, and trace identifiers so operators can understand why a transaction failed across several services. Which design quality is primarily being improved?<\/b><\/p>\n

                      \n
                    1. <\/b> Observability<\/span>
                      \n<\/span>2.<\/b> Database normalization only<\/span>
                      \n<\/span>3.<\/b> Source-code compression<\/span>
                      \n<\/span>4.<\/b> Packet fragmentation<\/span><\/li>\n<\/ol>\n

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

                      Explanation:<\/b> Observability is the ability to understand a system’s internal state from the telemetry it produces. Logs, metrics, traces, correlation IDs, and contextual application events help operators determine what happened across distributed services and why. Good observability is especially important in microservice environments where one user request can cross many application components. It supports troubleshooting, performance tuning, incident response, and reliability engineering. Merely collecting large volumes of unrelated logs is not enough; telemetry should be designed so it answers operational questions. Application observability is an explicit DEVCOR software design objective.<\/span><\/p>\n

                      Q11. A Cisco Webex integration needs to post a message automatically into a collaboration space when an infrastructure event occurs. Which concept does this demonstrate?<\/b><\/p>\n

                        \n
                      1. <\/b> Database sharding<\/span>
                        \n<\/span>2.<\/b> Static route configuration<\/span>
                        \n<\/span>3.<\/b> Local-only logging<\/span>
                        \n<\/span>4.<\/b> ChatOps using the Webex API<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 4. ChatOps using the Webex API<\/b><\/p>\n

                        Explanation:<\/b> ChatOps integrates operational workflows with collaboration platforms so applications and automation can post alerts, request approvals, trigger workflows, or provide operational information directly in team messaging spaces. An infrastructure event can cause an automation service to call the Webex API and post a message to the appropriate room. The current DEVCOR v1.1 blueprint explicitly includes constructing API requests to implement ChatOps with the Webex API. Cisco updated the terminology from the older Webex Teams naming while keeping the domain itself unchanged.<\/span><\/p>\n

                        Q12. A network automation application must represent Cisco device configuration using a structured data model that can be used with NETCONF or RESTCONF. Which modeling language is most appropriate?<\/b><\/p>\n

                          \n
                        1. <\/b> HTML<\/span>
                          \n<\/span>2.<\/b> SQL<\/span>
                          \n<\/span>3.<\/b> YANG<\/span>
                          \n<\/span>4.<\/b> CSS<\/span><\/li>\n<\/ol>\n

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

                          Explanation:<\/b> YANG is a data modeling language designed to describe configuration and operational data, RPCs, and notifications for network management. Model-driven interfaces such as NETCONF and RESTCONF use YANG models to define the structure and semantics of the data being manipulated. This provides a predictable machine-readable alternative to screen scraping or CLI parsing. Cisco’s DEVCOR course and exam content include data modeling with YANG and model-driven programmability as part of infrastructure automation and Cisco platform development. HTML, SQL, and CSS serve unrelated presentation or database functions.<\/span><\/p>\n

                          Q13. Which protocol encodes network configuration operations through RPC-style messages and commonly runs over SSH?<\/b><\/p>\n

                            \n
                          1. <\/b> NETCONF<\/span>
                            \n<\/span>2.<\/b> SNMP trap only<\/span>
                            \n<\/span>3.<\/b> TFTP<\/span>
                            \n<\/span>4.<\/b> CDP<\/span><\/li>\n<\/ol>\n

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

                            Explanation:<\/b> NETCONF is a model-driven network management protocol used to retrieve and modify configuration and operational data. It commonly uses SSH as a secure transport and represents operations using structured XML-based RPC messages. When combined with YANG data models, NETCONF provides consistent programmatic access to network devices without depending on CLI parsing. It supports configuration-oriented operations and datastore concepts that are useful for infrastructure automation. The current DEVCOR training content includes NETCONF, RESTCONF, YANG modeling, and automation of Cisco IOS XE infrastructure.<\/span><\/p>\n

                            Q14. A development team wants every new application change automatically built, tested, scanned, and packaged after a commit is merged. Which practice best describes this workflow?<\/b><\/p>\n

                              \n
                            1. <\/b> Manual change control only<\/span>
                              \n<\/span>2.<\/b> Static networking<\/span>
                              \n<\/span>3.<\/b> One-time compilation<\/span>
                              \n<\/span>4.<\/b> Continuous Integration<\/span><\/li>\n<\/ol>\n

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

                              Explanation:<\/b> Continuous Integration automatically integrates software changes into a shared development workflow and commonly triggers builds, unit tests, security scans, packaging, and other validation steps. The goal is to detect problems quickly after changes are introduced rather than waiting for large manual integration events. CI often feeds into continuous delivery or deployment processes that promote validated artifacts into later environments. DEVCOR includes integrating applications into existing CI\/CD environments and automating application releases as core preparation topics. A reliable pipeline should be repeatable, version-controlled, and able to report failures clearly.<\/span><\/p>\n

                              Q15. A Dockerized application should expose TCP port 8080 inside the container and map it to TCP port 80 on the host. Which concept is being used?<\/b><\/p>\n

                                \n
                              1. <\/b> Git branch merging<\/span>
                                \n<\/span>2.<\/b> Container port publishing or mapping<\/span>
                                \n<\/span>3.<\/b> Database indexing<\/span>
                                \n<\/span>4.<\/b> OAuth authorization<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. Container port publishing or mapping<\/b><\/p>\n

                                Explanation:<\/b> Container port publishing maps a port on the host system to a listening port inside the container. This allows clients to reach a containerized application through a host address even when the application itself listens on a different internal port. Docker commonly expresses this mapping with host and container port values. Port mapping is separate from application authentication and source control. DEVCOR training includes containerizing applications with Docker and deploying applications, so candidates should understand container behavior, packaging, and connectivity concepts in addition to writing application code.<\/span><\/p>\n

                                Q16. A software package depends on a specific version of an external Python library. What is the main benefit of explicitly defining and managing that dependency?<\/b><\/p>\n

                                  \n
                                1. <\/b> It guarantees the application never contains vulnerabilities<\/span>
                                  \n<\/span>2.<\/b> It eliminates the need for testing<\/span>
                                  \n<\/span>3.<\/b> It improves reproducibility and reduces unexpected version incompatibilities<\/span>
                                  \n<\/span>4.<\/b> It makes Git unnecessary<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. It improves reproducibility and reduces unexpected version incompatibilities<\/b><\/p>\n

                                  Explanation:<\/b> Dependency management records which external packages and versions an application requires. Pinning or constraining versions helps different developers, CI systems, and deployment environments install consistent dependency sets and reduces unexpected behavior caused by incompatible releases. Dependency management also supports vulnerability analysis and controlled upgrades, although it cannot guarantee that dependencies are vulnerability-free. Testing remains necessary, and Git still manages source history. DEVCOR explicitly includes release packaging and dependency-management concepts because reliable software delivery depends on reproducible build inputs and controlled dependency lifecycles.<\/span><\/p>\n

                                  Q17. An Ansible automation task must configure many network devices repeatedly and should leave devices unchanged when they already match the intended state. Which automation property is most desirable?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Idempotency<\/span>
                                    \n<\/span>2.<\/b> Random configuration changes<\/span>
                                    \n<\/span>3.<\/b> Permanent manual intervention<\/span>
                                    \n<\/span>4.<\/b> Uncontrolled side effects<\/span><\/li>\n<\/ol>\n

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

                                    Explanation:<\/b> Idempotent automation converges infrastructure toward the desired state without making unnecessary changes when that state is already satisfied. If an Ansible playbook is run several times against a correctly configured device, later runs should ideally report little or no change. This improves safety, predictability, and repeatability and makes recovery from partial failures easier. Configuration-management and Infrastructure as Code workflows rely heavily on this concept. DEVCOR’s infrastructure and automation domain includes orchestration, Ansible-related network configuration, Terraform, and Cisco infrastructure automation topics.<\/span><\/p>\n

                                    Q18. A Terraform configuration manages network infrastructure. An engineer changes the desired configuration and wants to preview the proposed modifications before applying them. Which Terraform operation is most appropriate?<\/b><\/p>\n

                                      \n
                                    1. <\/b> terraform destroy<\/span>
                                      \n<\/span>2.<\/b> terraform plan<\/span>
                                      \n<\/span>3.<\/b> git init<\/span>
                                      \n<\/span>4.<\/b> docker run<\/span><\/li>\n<\/ol>\n

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

                                      Explanation:<\/b> terraform plan<\/span> evaluates the current state, desired configuration, and provider information and produces a proposed execution plan showing which resources Terraform expects to create, modify, or destroy. Reviewing the plan before <\/span>terraform apply<\/span> can identify unexpected or risky changes. This is especially important for network and security infrastructure, where one incorrect change can cause widespread impact. Terraform replaced Puppet manifest content in the updated DEVCOR v1.1 infrastructure-and-automation blueprint, reflecting Cisco’s current exam focus.<\/span><\/p>\n

                                      Q19. An application writes events such as <\/b>request_id<\/b>, <\/b>user_id<\/b>, <\/b>service<\/b>, <\/b>severity<\/b>, and <\/b>duration_ms<\/b> as consistently named JSON fields. What is the primary operational benefit?<\/b><\/p>\n

                                        \n
                                      1. <\/b> It eliminates application failures<\/span>
                                        \n<\/span>2.<\/b> It removes the need for tracing<\/span>
                                        \n<\/span>3.<\/b> Structured logs are easier to parse, search, correlate, and automate<\/span>
                                        \n<\/span>4.<\/b> It prevents every security vulnerability<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3. Structured logs are easier to parse, search, correlate, and automate<\/b><\/p>\n

                                        Explanation:<\/b> Structured logging places event attributes into predictable machine-readable fields rather than embedding all information in arbitrary free-form text. This makes logs easier for observability platforms to index, filter, correlate, aggregate, and analyze programmatically. Correlation identifiers such as <\/span>request_id<\/span> are particularly useful in distributed applications where one transaction crosses many services. Structured logging does not eliminate failures or replace traces and metrics, but it greatly improves troubleshooting. Diagnosing application problems from logs and evaluating observability are explicitly included in the current DEVCOR software-development domain.<\/span><\/p>\n

                                        Q20. A REST API returns HTTP 404 when an application requests a resource that does not exist. The missing resource is required for the workflow to continue. What should robust consumer code do?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Retry the same request forever<\/span>
                                          \n<\/span>2.<\/b> Treat the error as unrecoverable for that workflow and handle it explicitly<\/span>
                                          \n<\/span>3.<\/b> Convert the status code to HTTP 200<\/span>
                                          \n<\/span>4.<\/b> Ignore the response body and continue as if the resource existed<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2. Treat the error as unrecoverable for that workflow and handle it explicitly<\/b><\/p>\n

                                          Explanation:<\/b> Robust API consumers distinguish between transient errors and unrecoverable conditions. A timeout or rate-limit response may justify retrying, but a confirmed 404 for a required resource usually means repeating the identical request will not solve the problem. The application should enter an appropriate error path, such as reporting that the resource is missing, aborting the dependent workflow, or requesting corrected input. Infinite retries waste resources and can hide the actual failure. The current DEVCOR API domain specifically requires candidates to implement control flow for unrecoverable REST API errors.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Cisco CCNP Automation 350-901 Exam Dumps and Practice Test Dumps. Q1. A Python application consumes a REST API that limits clients to 100 requests per minute. The API returns HTTP 429 when the limit is exceeded. What should the application do? Immediately repeat requests in a tight loop 2. Respect rate-limit information and […]<\/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\/18163"}],"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=18163"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18163\/revisions"}],"predecessor-version":[{"id":18164,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18163\/revisions\/18164"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18163"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18163"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18163"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}