DevNet Associate (DEVASC) Exam Guide: What the Former Exam Covered and How to Prepare
The former Cisco DevNet Associate exam, 200-901 DEVASC, validated entry-level ability to develop software, use APIs, work with Cisco platforms, secure applications, and automate infrastructure. It served candidates moving between networking and programming, including developers who needed network context and network professionals learning automation. This guide helps you make the most important decision first: whether you are preparing for historical DEVASC material or the current successor, 200-901 CCNAAUTO, before you invest time in labs, courses, or practice questions.
Is DEVASC still the current exam?
DEVASC is the former name for the entry-level Cisco DevNet exam. Cisco states that the DevNet track transitioned to the CCNA, CCNP, and CCIE Automation track effective February 3, 2026, and identifies 200-901 CCNAAUTO, Automating Networks Using Cisco Platforms, as the successor. Confirm the current registration and exam information on Cisco’s site before scheduling.
What changed for candidates
Cisco states that the former DevNet Associate certification became CCNA Automation on February 3, 2026. Cisco also states that the content from the previous 200-901 DEVASC exam remains unchanged in the CCNA Automation version and that only the exam name was updated. That makes the DEVASC blueprint useful for study, but the current exam name and certification outcome matter when you book.
How to use this guide
Use the domain and task guidance here to build technical readiness, especially if your materials still use the DEVASC label. For a live appointment, eligibility question, language detail, delivery option, or current policy, use Cisco’s current CCNA Automation exam page rather than relying on an older DEVASC reference. Do not treat an archived exam page as proof of present scheduling conditions.
What skills did the exam validate?
Cisco described the former DEVASC exam as assessing software development and design, API usage, Cisco platforms and development, application development and security, and infrastructure and automation. The v1.1 blueprint also lists Network Fundamentals as a domain. In practice, preparation needed to connect code, network behavior, platform APIs, security controls, and automation workflows rather than study Python in isolation.
The six blueprint domains
Cisco’s DEVASC v1.1 blueprint lists six domains: Software Development and Design; Understanding and Using APIs; Cisco Platforms and Development; Application Development and Security; Infrastructure and Automation; and Network Fundamentals. Treat these as a map of capabilities. The blueprint is more useful when converted into tasks you can perform, explain, and troubleshoot.
The candidate profile the blueprint suits
The subject fits a mixed technical audience. A developer may need stronger network fundamentals and Cisco product context. A network engineer may need more practice with Python, data formats, version control, and API behavior. An automation-focused administrator may recognize the infrastructure concepts but still need to explain authentication, error handling, testing, and secure application design.
Which topics deserve the earliest study time?
Start with the blueprint domains that expose gaps in your working ability, not simply the topics you find interesting. Cisco assigned 15% to Software Development and Design and 20% to Understanding and Using APIs, so both deserve deliberate study. The remaining domains still require coverage because the blueprint spans six areas and tests connected judgment rather than one narrow programming skill.
Software Development and Design — 15%
Software Development and Design carries 15% in Cisco’s DEVASC exam-topics material. Build a foundation in readable Python, data structures, control flow, functions, exceptions, modules, and basic testing. Add software design habits: separate configuration from logic, validate inputs, make failures visible, and write code that another engineer can maintain.
Understanding and Using APIs — 20%
Understanding and Using APIs carries 20% in Cisco’s DEVASC exam-topics material. Practice constructing REST requests, selecting HTTP methods, reading response codes, handling authentication, and interpreting JSON. Include webhooks, API styles, and Python scripts using the requests library. Your goal is not to remember isolated terms; it is to predict what a client sends, what a service returns, and what should happen when the request fails.
The four remaining domains
Cisco’s blueprint also covers Cisco Platforms and Development, Application Development and Security, Infrastructure and Automation, and Network Fundamentals. Allocate study time across all four. Learn enough platform purpose and interface behavior to choose an appropriate automation approach, then connect it to security, infrastructure state, and networking concepts such as addressing, protocols, and traffic flow.
How should you assess your starting point?
Before selecting a course or practice schedule, perform a capability audit. Write and run a small Python program, call a documented REST endpoint, inspect a JSON response, explain a basic network flow, and describe how you would protect a secret. Record where you need prompts or reference material. Those observations should determine your first study block.
A useful five-part diagnostic
Check five abilities: programming, API reasoning, Cisco platform awareness, security and application design, and network fundamentals. For programming, look for confidence with functions, collections, exceptions, and reusable modules. For APIs, test whether you can distinguish authentication failure from a malformed request or a server-side problem. For networking, explain what must be true before an application can reach its target.
How to interpret the result
If you cannot yet produce a small working script, begin with Python and basic data handling. If your code works but API calls feel opaque, focus on request construction, authentication, response parsing, and error handling. If APIs are comfortable but platform selection is weak, map Cisco products and their automation interfaces. If networking is the gap, pause advanced automation and repair the underlying concepts first.
What Python practice is most relevant?
Practice short automation programs that read input, call a service, transform returned data, and report useful errors. Cisco’s DEVASC topics included Python scripting with Cisco SDKs and named platforms such as Meraki, Cisco DNA Center, ACI, Cisco SD-WAN, NSO, Webex, Firepower, Umbrella, and ISE. Study the purpose and integration pattern of each platform rather than trying to memorize product descriptions.
A progression that builds judgment
Begin with plain Python: variables, lists and dictionaries, loops, conditionals, functions, modules, exceptions, and file handling. Move to JSON serialization and deserialization. Then use requests to make an authenticated call against a documented service or permitted lab endpoint. Finally, refactor the script so credentials are not embedded in source code, failures produce actionable messages, and repeated logic is reusable.
What to inspect in your own code
After each exercise, ask whether the code handles an empty response, an unexpected field, a timeout, an authentication failure, and a non-success HTTP response. Check whether it logs sensitive values. Confirm that the program distinguishes input validation from service failure. These reviews train the reasoning that short syntax drills do not provide.
How do you study REST APIs without memorizing trivia?
Treat every API exercise as a complete exchange: identify the resource, choose the method, supply the required headers or body, authenticate safely, inspect the response, and decide what the client should do next. Cisco’s topics specifically included REST API requests, webhooks, HTTP response codes, API authentication, API styles, and requests-based Python scripts.
Use a request worksheet
For each endpoint, document the resource URL, method, parameters, headers, authentication mechanism, request body, expected response, and failure behavior. Add the operation’s effect: does it read state, create an object, modify an object, or remove one? This prevents a common mistake—remembering a method name without understanding the resource lifecycle.
Practice response-driven decisions
Do not stop after a successful response. Examine the status code, returned data, pagination or filtering behavior where documented, and any useful error payload. Then decide whether to retry, correct the request, refresh credentials, or surface the problem. Webhooks deserve a similar treatment: identify the event, validate the received data, and design a safe handler rather than trusting every incoming request.
Keep authentication separate from application logic
Use the service’s documented authentication method and keep secrets outside source code. In a lab, use environment variables or another permitted secret mechanism. Make the authentication step explicit in your notes, because an API call that works only through a manually configured tool is not yet a reliable automation solution.
How should Cisco platforms fit into the plan?
Cisco platform study is most effective when organized by automation purpose. Cisco’s DEVASC blueprint included Meraki, Cisco DNA Center, ACI, Cisco SD-WAN, NSO, Webex, Firepower, Umbrella, and ISE, along with Python scripting and Cisco SDKs. For each platform, learn what it manages, which API or SDK pattern exposes it, and what kind of developer or operator task it supports.
Build a platform comparison sheet
Create one row per named platform and record its broad role, the type of object or service it controls, the likely interface used for automation, and one security consideration. Keep the entries concise and verify them against Cisco documentation or authorized learning content. The purpose is to distinguish platforms and select sensible tools, not to create an encyclopedic product catalogue.
Connect platform knowledge to code
For every platform you study, write a small workflow in plain language: authenticate, retrieve state, inspect the result, make a controlled change, and verify the outcome. Where a hands-on environment is unavailable, trace the workflow from official API documentation and identify the request, response, and failure points. Do not invent access or claim that a simulated result proves production behavior.
What application security should you be able to explain?
Security preparation should cover both the application and the automation path. Study secret handling, authentication and authorization distinctions, input validation, safe error reporting, transport protection, dependency awareness, and the risks of accepting unvalidated webhook data. The practical test is whether you can identify an unsafe design and propose a safer alternative without obscuring the operational requirement.
Review security at each layer
For the client, ask how credentials are stored and rotated. For the request, ask whether the method, headers, parameters, and body are validated. For the service, ask what permissions the identity has. For the response, ask whether sensitive data is exposed or logged. For the deployment, ask whether configuration differs safely between environments. This layered review is more useful than memorizing a list of vulnerabilities.
Avoid the least-privilege blind spot
An automation script may need access to an API without needing unrestricted administrative rights. In your study notes, state what the script must read or change and what it should not be allowed to do. Also record how failures are detected. A secure design that silently ignores authorization errors is not operationally safe.
How do infrastructure and automation topics connect?
Infrastructure automation is about representing desired state, applying repeatable changes, and verifying results. Study how automation tools, APIs, SDKs, and configuration data fit together. Cisco’s v1.1 release notes say the domains remained identical compared with v1.0, while some tasks were updated for product naming changes, end-of-life products, and Terraform use. Use the v1.1 material as your controlling blueprint.
Separate intent from implementation
When reviewing an automation workflow, first state the desired infrastructure result. Then identify the data model, tool, API, or SDK that can express it. Finally define validation and rollback considerations. This sequence helps you answer scenario questions where several technologies appear plausible but only one matches the stated operational objective.
Study Terraform in context
Because Cisco’s v1.1 release notes mention updates involving Terraform use, include Terraform concepts where they appear in the current blueprint or official learning material. Focus on why declarative configuration, state, variables, and repeatable changes matter. Do not let tool syntax replace understanding of the infrastructure object being managed.
How much network fundamentals do developers need?
You need enough networking knowledge to understand the conditions under which an application and its automation service communicate. Review addressing, routing, transport behavior, common application protocols, name resolution, and the relationship between a client, network device, controller, and API service. Then apply those concepts to a failed request: determine whether the problem is reachability, authentication, request construction, or service behavior.
Trace a request from code to service
Draw the path from the Python process to the target API. Label the destination name, address, transport connection, application request, identity, and response. Add possible control points such as a firewall or proxy. This simple diagram makes it easier to distinguish a connection problem from an HTTP error and an HTTP error from an application-level failure.
Do not postpone networking completely
Candidates from a programming background often defer networking until the end because code feels more familiar. That creates a weak foundation for platform automation. Review networking alongside API labs so every request exercise includes a short explanation of how the client reaches the service and what could block the exchange.
What study sequence works for a mixed syllabus?
Use a dependency-first sequence: programming and data handling, networking basics, API mechanics, Cisco platform workflows, security, and integrated automation. Revisit earlier skills inside later exercises. This prevents a common failure mode in which a candidate reads about platforms and tools but cannot diagnose a broken request or explain why a script is safe and repeatable.
Stage one: establish the foundations
Start by refreshing Python syntax, structured data, HTTP vocabulary, and core networking. Produce small working scripts rather than copying large examples. At the end of this stage, you should be able to read a short program, predict its output, identify an exception path, and explain the broad purpose of a REST request.
Stage two: make API calls deliberate
Next, work through authenticated requests, response parsing, status-code handling, and webhooks. Keep a troubleshooting journal. For each failure, record the symptom, the likely layer, the evidence you checked, and the correction. This journal becomes a compact revision resource and discourages random changes that happen to make one exercise pass.
Stage three: map Cisco platforms to use cases
Study the Cisco platforms named in the blueprint and connect each to a realistic automation task. Use official documentation and authorized labs. For each task, write the workflow before writing code. This develops platform selection and design judgment instead of encouraging product-name recall without context.
Stage four: integrate and review
Finish with mixed exercises that combine code, API behavior, platform context, security, infrastructure, and networking. Review the blueprint after each exercise and mark the domain that the task tested. If one domain repeatedly receives no evidence in your notes or lab work, schedule targeted review rather than assuming familiarity.
How can you build a practical weekly roadmap?
A useful roadmap alternates learning, implementation, explanation, and review. Assign each study session a visible output: a script, a request worksheet, a platform comparison entry, a network diagram, a security review, or a troubleshooting note. The exact calendar should reflect your available time and starting level; the outputs are more reliable progress markers than hours spent reading.
A repeatable session format
Begin with a short recall exercise without notes. Study one bounded topic from the official blueprint or learning material. Apply it in code, a permitted lab, or a written scenario. Explain the result in your own words. End by recording one unresolved question and one correction to your notes. This cycle exposes false confidence quickly.
A final review cycle
Near the end of preparation, stop collecting unrelated resources. Rework missed questions or failed labs by explaining the underlying reason, not just the correct option. Rebuild a small API workflow from a blank file, trace its network path, and review its security decisions. Then compare your evidence with every blueprint domain before deciding whether to schedule.
Which mistakes waste the most preparation time?
The largest avoidable mistakes are studying only Python, memorizing HTTP terms without sending requests, ignoring networking, treating product names as interchangeable, and using unverified question collections as a substitute for understanding. A candidate is better served by fewer resources used actively: one current blueprint, official references, permitted practice environments, and notes that explain decisions.
Mistake: treating the blueprint as a vocabulary list
A heading such as API authentication is not a complete study task. Turn it into actions: identify the credential method, place it safely, send the request, inspect the result, and handle failure. Do the same for webhooks, SDKs, infrastructure, and security. Action-based notes reveal gaps that copied definitions conceal.
Mistake: trusting stale product or exam labels
Cisco’s release notes document naming and task updates, and Cisco later announced the transition from DevNet to Automation. Check the version and date of every guide you use. If a resource uses DEVASC, determine whether it is explaining the former exam content or claiming to describe current registration details. Do not let an old label decide your booking.
Mistake: using dumps as a learning strategy
Memorized or unauthorized question material cannot replace the ability to reason through an unfamiliar API, code fragment, platform scenario, or security decision. It can also leave you studying content that is outdated or misrepresented. Use legitimate practice to diagnose knowledge gaps, then return to the blueprint and official technical material for correction.
What were the former exam’s documented details?
Cisco’s former exam overview identified DEVASC as 200-901 and associated it with Cisco Certified DevNet Associate. The overview stated that the former exam duration was 120 minutes and that it was available in English. These details describe the former DEVASC exam; they should not be assumed to describe every current CCNAAUTO scheduling or delivery condition.
What to verify before scheduling
Before you book, check Cisco’s current CCNA Automation page for the exam title, registration path, available delivery choices, language information, policies, and any current requirements. The supplied former overview supports the historical English and 120-minute details only. A current appointment decision should be based on current Cisco information, not on a third-party summary.
Certification outcome after the transition
Cisco identifies 200-901 CCNAAUTO as Automating Networks Using Cisco Platforms and states that passing it earns the CCNA Automation certification. Cisco also states that the result can count toward recertification goals. Confirm the applicable current rules on Cisco’s certification site if recertification is the reason you are taking the exam.
How do you decide whether you are ready?
Readiness means you can explain and apply the blueprint, not that you have seen every possible question. Schedule only after you can complete representative tasks without step-by-step copying: write and troubleshoot a modest Python workflow, reason through a REST exchange, connect a Cisco platform to an automation use case, identify security weaknesses, and trace a network-related failure.
Use evidence instead of confidence
Create a checklist with the six official domains. For each domain, attach evidence such as a completed lab, a corrected script, a diagram, or a written explanation. Mark a domain as weak when you can recognize terminology but cannot produce or assess an example. Confidence based only on repeated reading is not a reliable scheduling signal.
Make the scheduling decision explicit
If several foundational tasks still require extensive lookup, continue preparation and target those dependencies. If you can perform the tasks but make repeatable errors, schedule focused remediation and reassess. If your evidence is consistent across the domains and you have verified the current exam details with Cisco, choose an appointment that leaves enough time for calm review rather than last-minute cramming.
What should you do next?
First, confirm whether your target is the current 200-901 CCNAAUTO or a historical DEVASC study objective. Next, download the applicable Cisco blueprint and mark your gaps across all six domains. Then begin one small Python-and-API workflow, document its network path and security decisions, and use the result to choose your next study block.
A focused first checklist
Confirm the current exam name on Cisco’s official page. Read the v1.1 topic document and release notes. Inventory your Python, API, networking, platform, security, and automation skills. Select an authorized lab or documented service. Keep a troubleshooting journal. Review the official source again after each major study cycle so stale material does not quietly shape your plan.
The standard to carry into the exam
Aim to understand why an automation solution works, how to detect when it does not, and how to make it safer and more maintainable. That standard aligns preparation with the connected skills represented by the former DEVASC blueprint and remains more durable than memorizing isolated answers or product labels.
Conclusion
DEVASC preparation should begin with an exam-status check, because Cisco moved the DevNet Associate track to Automation and identifies 200-901 CCNAAUTO as its successor. The former blueprint remains a useful technical map: build Python and API fluency, connect that work to Cisco platforms, and reinforce it with security, infrastructure, and networking practice. Use documented requirements for scheduling decisions and practical evidence from your own exercises for readiness decisions.
