What the 200-901 DEVASC actually tests

The 200-901 DevNet Associate (DEVASC) is Cisco’s associate-level exam for people who sit between software and infrastructure: network engineers learning automation, developers working with Cisco platforms, and operations staff building scripts, integrations, and API-driven workflows.

This is not a pure programming exam. It is also not a traditional CCNA-style memorization test. You need enough coding literacy to read and fix Python, enough networking knowledge to understand what the code is doing, and enough API fluency to work with Cisco platforms and modern application components.

The current blueprint is built around these domains:

Software Development and Design — 15%
Understanding and Using APIs — 20%
Cisco Platforms and Development — 15%
Application Deployment and Security — 15%
Infrastructure and Automation — 20%
Network Fundamentals — 15%

That weighting matters. If you are short on time, the highest return areas are:

APIs
Infrastructure and Automation
Software Development and Design

Expect a mix of straightforward recall, scenario questions, output interpretation, and “what would you use here?” questions. You are often choosing the right protocol, data format, HTTP method, auth mechanism, automation tool, or Cisco platform for a given task.

What trips people up:

Confusing REST, RESTCONF, and NETCONF
Weakness in HTTP methods, status codes, headers, and auth
Only knowing Python syntax, but not how Python is used in automation
Knowing networking, but not JSON/YAML/XML or data modeling concepts
Forgetting the specifics of Cisco DNA Center, Meraki, Webex, UCS Manager, and ACI APIs
Underestimating the application deployment/security domain

If you have a CCNA background, networking and some automation concepts will feel familiar. If you come from software, APIs and Python may be comfortable, but you will need to close the gap on routing, switching, wireless, and controller-based management.

Start with code literacy, not full-stack development

The Software Development and Design (15%) domain is where Cisco checks whether you can think like an automation engineer rather than a general-purpose developer. You do not need to be a professional software engineer. You do need to be comfortable reading code and understanding software structure.

Focus your study on these areas:

Programming concepts: variables, data types, conditionals, loops, functions, classes, exceptions
Python basics for automation
Data formats: JSON, YAML, XML
Version control concepts: especially Git basics
Development methodologies: waterfall vs agile, CI/CD awareness
Design models: monolithic vs microservices, event-driven patterns, test-driven thinking

What to know cold in Python:

Lists, dictionaries, tuples, sets
Iteration over nested data structures
Function arguments and return values
Reading and writing files
Importing modules
Exception handling with try/except
Parsing JSON
Sending HTTP requests with requests

You should be able to read code like this and explain what it does:

import requests

url = "https://api.meraki.com/api/v1/organizations"
headers = {
    "X-Cisco-Meraki-API-Key": "<key>",
    "Content-Type": "application/json"
}

response = requests.get(url, headers=headers)
if response.status_code == 200:
    data = response.json()
    for org in data:
        print(org["name"])
else:
    print(response.status_code, response.text)

For data formats, know when each is common:

JSON: dominant in REST APIs
YAML: common in configuration and automation tools like Ansible
XML: still important for NETCONF and some Cisco platforms

Do not just memorize syntax. Practice converting between structures mentally. If you see a JSON response, you should know how Python would access nested keys.

Git is tested at a conceptual level more than a command-depth level, but know:

What a repository, commit, branch, and merge are
Why version control matters for infrastructure code
The purpose of pull requests and collaborative workflows

This domain is one of the more manageable ones if you already script. If you do not, spend your first week here. The exam assumes you can parse code examples without panic.

APIs are the center of this exam

The Understanding and Using APIs (20%) domain is the heart of DEVASC. If you want one area to overprepare, make it this one.

You need practical fluency with API behavior, not abstract definitions.

The API topics that show up repeatedly

REST architecture principles
HTTP methods: GET, POST, PUT, PATCH, DELETE
Status codes: 200, 201, 204, 400, 401, 403, 404, 500
Headers: Content-Type, Accept, auth-related headers
Authentication: Basic, Bearer token, API key, OAuth concepts
Pagination, rate limiting, idempotency
Data encoding and serialization
JSON parsing
Webhooks and event-driven integrations
Troubleshooting API calls using tools such as Postman or curl

Know the difference between these operations:

GET retrieves data
POST creates a resource or triggers an action
PUT typically replaces a full resource
PATCH partially modifies a resource
DELETE removes a resource

Know status code intent:

200 OK: successful request
201 Created: resource created
204 No Content: success, nothing returned
400 Bad Request: malformed or invalid request
401 Unauthorized: missing/invalid authentication
403 Forbidden: authenticated but not allowed
404 Not Found: resource doesn’t exist
500 Internal Server Error: server-side failure

Tools you should actually use while studying

Postman for building and testing API calls
curl for simple command-line requests
Python requests for scripted interaction
Cisco DevNet Sandbox for hands-on API work

A lot of candidates read docs and skip making live requests. That is a mistake. You remember APIs better once you have:

Authenticated to a real endpoint
Broken a request with bad headers
Parsed a JSON response
Handled pagination
Seen 401/403/404 errors in practice

REST vs NETCONF vs RESTCONF

This is a frequent confusion point.

REST: architectural style using HTTP, usually with JSON
NETCONF: network configuration protocol using XML, commonly over SSH, supports transactions and datastore operations
RESTCONF: REST-like interface to network configuration/state data, often using YANG models and JSON/XML representations over HTTP(S)

Know where YANG fits: it is a data modeling language used with NETCONF/RESTCONF to define configuration and operational data structures.

Webhooks matter more than many people expect

Understand the difference between:

Polling: your app repeatedly asks if something changed
Webhook: the remote system sends an event when something happens

Know why webhooks are efficient for event-driven automation and what security concerns they introduce, such as validating source authenticity.

If you can read an API endpoint, identify the method, auth type, expected payload, and likely response code, you are in good shape for this domain.

Cisco platforms: know the personalities, not just the names

The Cisco Platforms and Development (15%) domain is where the exam gets product-specific. You do not need deep admin-level expertise in every platform, but you do need to know what each platform is for, how developers interact with it, and what kind of automation model it supports.

The main platforms to know:

Cisco DNA Center
Cisco Meraki
Cisco Webex
Cisco UCS Manager
Cisco ACI
Cisco vManage
Awareness of IOS XE programmability

DNA Center

Know DNA Center as Cisco’s controller for enterprise campus and branch automation, assurance, and policy-based management.

Study:

Intent-based networking concepts
Northbound APIs
Typical use cases: device inventory, assurance data, provisioning workflows
Authentication patterns used by DNA Center APIs

Meraki

Meraki is usually one of the easier platforms to grasp because the API is clean and well-documented.

Know:

Dashboard API basics
API key authentication
Common tasks: organizations, networks, devices, SSIDs, clients
Cloud-managed architecture

Webex

Webex shows up because collaboration APIs are a major Cisco developer story.

Know:

Webex REST APIs
Bots, messaging, rooms/spaces, webhooks
OAuth concepts in Webex integrations

UCS Manager

Know what UCS Manager controls: compute infrastructure, service profiles, and unified management of Cisco UCS systems.

You may see questions on XML API behavior and automation use cases.

ACI

Know the policy-driven data center angle.

Study:

Application policy model at a high level
APIC as the controller
REST API access to policy/configuration
Why ACI is different from traditional box-by-box configuration

vManage and SD-WAN

Know that vManage is the management plane for Cisco SD-WAN and supports API-driven operations.

IOS XE programmability

Understand that modern network devices expose programmable interfaces including:

NETCONF
RESTCONF
Model-driven telemetry
Guest shell/app hosting awareness at a high level

For this whole domain, think in terms of:

What problem the platform solves
Whether it is cloud-managed or controller-based
Which APIs and auth methods are commonly used
What kinds of objects you manipulate through automation

Do not try to become an expert in every GUI. Stay focused on developer interaction points.

Automation and infrastructure: where networking meets programmability

The Infrastructure and Automation (20%) domain is where traditional network engineers usually regain confidence. But it is broad, and broad means easy to underestimate.

You need to understand both the network side and the automation side.

Core topics to cover

Automation principles and benefits
Configuration management concepts
Controllers vs device-by-device management
Agent-based vs agentless automation
Ansible basics
Puppet, Chef, and Salt at a conceptual level
JSON, XML, YAML in infrastructure workflows
Model-driven programmability
Telemetry and event-driven automation
CI/CD relevance to infrastructure changes

Ansible is the one to know best

You should know:

What a playbook is
Inventory basics
YAML structure
Idempotency in automation
Why Ansible is considered agentless
SSH-based operation for many network use cases

You do not need to write advanced playbooks from memory, but you should be able to recognize one and understand task flow.

Controller-based automation

Cisco likes testing the shift from manual CLI configuration to centralized, API-driven operations.

Know why organizations move toward controllers:

Consistency
Scale
Policy enforcement
Faster provisioning
Better visibility and assurance

Data models and telemetry

Understand these distinctions:

Traditional monitoring polls devices periodically
Telemetry streams data continuously or on change
Model-driven telemetry uses structured data models

This matters because modern automation is not only about pushing config. It is also about consuming operational state and reacting to events.

Infrastructure as code mindset

Cisco does not test this as deeply as a cloud-native cert would, but you should understand the principles:

Version-controlled configurations
Repeatable deployment workflows
Testing and validation before production rollout
Rollback planning

If you can explain why a team would use Ansible plus Git plus APIs instead of ad hoc CLI changes, you are thinking at the right level.

Don’t neglect app deployment and security

Many candidates leave the Application Deployment and Security (15%) domain too late because it feels less “Cisco.” That is risky. It is a compact domain with a lot of easy points if you study it directly.

Deployment topics to know

Containers and container benefits
Docker basics: images, containers, registries, Dockerfiles at a conceptual level
Virtual machines vs containers
Cloud deployment models: public, private, hybrid
CI/CD pipeline concepts
Basic understanding of load balancing and scalability patterns

You are not being tested as a Kubernetes administrator. Stay practical:

Why containers start faster than VMs
Why containers package application dependencies consistently
Where images come from
Why microservices often pair with containers

Security topics that matter for DEVASC

Authentication vs authorization
OAuth 2.0 at a practical level
API keys, tokens, and secrets handling
TLS/HTTPS basics
Secure coding awareness
Input validation and common web/API security thinking
Secure storage of credentials

Be able to distinguish:

Basic Auth: simple, often base64-encoded credentials, should be protected by TLS
Token-based auth: bearer tokens used in many APIs
OAuth: delegated authorization, common in integrations like Webex

Know common security good practices for automation scripts:

Do not hardcode credentials in scripts
Use environment variables or secure vaulting where possible
Validate certificates appropriately
Limit API privileges to least privilege
Log carefully without exposing secrets

This domain is usually more conceptual than configuration-heavy. That makes it very learnable in a short window if you review it systematically.

The networking you need for DEVASC

The Network Fundamentals (15%) domain is not as deep as CCNA, but it is not optional. Cisco expects you to understand the environment your code interacts with.

Cover these areas:

OSI and TCP/IP models
IP addressing, subnetting basics, and default gateways
Routing and switching fundamentals
DNS, DHCP, NAT, NTP
TCP vs UDP
Common ports and protocols: HTTP, HTTPS, SSH, DNS
Wireless basics and controller-based wireless concepts
Network components: routers, switches, firewalls, controllers, load balancers

You do not need deep route selection troubleshooting, but you do need to know enough to interpret automation tasks correctly.

Examples:

If an API call to a controller fails, is it auth, DNS, routing, or TLS?
If a script provisions a VLAN or SSID, what network component is actually being changed?
If telemetry data is delayed, what transport or connectivity issue might explain it?

A software-only candidate should spend extra time here. A network engineer can usually review this domain faster, but should still revisit protocol behavior and ports because those details often appear in API and security questions too.

A realistic prep plan based on your background

For DEVASC, the right timeline depends heavily on whether you come from networking, software, or neither.

If you already work in networking and know basic Python

Plan 5 to 7 weeks, about 7 to 10 hours per week.

Suggested order:

APIs and HTTP fundamentals
Cisco platforms
Infrastructure automation and Ansible
Application deployment/security
Targeted Python/data format review
Practice questions and weak-area cleanup

If you are a developer with limited networking experience

Plan 7 to 9 weeks, about 8 to 12 hours per week.

Suggested order:

Network fundamentals
Infrastructure concepts and controllers
APIs
Cisco platforms
Application deployment/security
Practice-heavy review

If you are new to both automation and Cisco enterprise platforms

Plan 10 to 12 weeks, about 10 to 12 hours per week.

Use three phases:

Phase 1: Python, JSON/YAML/XML, HTTP, networking basics
Phase 2: Cisco platforms, RESTCONF/NETCONF, Ansible, deployment/security
Phase 3: Labs, practice questions, timed review

A practical weekly cadence

Use a repeating pattern instead of random study:

Day 1: Read one blueprint topic from official docs or OCG
Day 2: Build or test something in Postman/Python
Day 3: Review notes and summarize concepts in your own words
Day 4: Do practice questions only on that domain
Day 5: Revisit wrong answers and lab the weak spots
Weekend: Mixed-domain review and one timed session

How to use the 557 Truekia practice questions well

Do not burn through all 557 early.

Use them in three passes:

Pass 1: After each domain, do 25 to 50 related questions untimed
Pass 2: Midway through prep, do mixed sets of 60 to 80 questions timed
Pass 3: Final two weeks, focus only on missed questions and weak domains

The goal is not just score improvement. It is pattern recognition: spotting whether a question is really testing HTTP behavior, platform knowledge, auth, or network fundamentals.

Resources worth your time for DEVASC

Use a small set of high-quality resources and go deep. This exam rewards hands-on familiarity more than broad resource collecting.

Official and Cisco-first resources

Cisco Learning Network – DEVASC exam topics page
Cisco DevNet documentation and learning labs
Cisco DevNet Sandbox for hands-on work with platforms and APIs
Cisco API documentation for Meraki, Webex, DNA Center, ACI, and others

Books and structured study

Cisco DevNet Associate DEVASC 200-901 Official Cert Guide by Chris Jackson and Jason Gooley
Network Programmability and Automation by Jason Edelman, Scott S. Lowe, and Matt Oswalt

The OCG maps well to the exam and is the best anchor resource. The Edelman/Lowe/Oswalt book is excellent for understanding automation thinking beyond exam cram.

Video training

Cisco U. DEVASC-related training paths if available to you
CBT Nuggets DEVASC course options, especially if you learn better from guided demos
INE networking automation content for deeper technical reinforcement

Hands-on tools to install and use

Python 3
Postman
VS Code
Git
Docker Desktop or equivalent container runtime
Ansible in a lab environment

The minimum hands-on lab list

Before exam day, make sure you have personally done these tasks:

Sent GET and POST requests to a real API
Authenticated with an API key and with a token
Parsed JSON in Python
Read a small YAML playbook and understood its tasks
Compared NETCONF and RESTCONF examples
Used at least one Cisco DevNet Sandbox environment
Created or inspected a Docker image/container workflow
Followed a Webhook example, ideally with Webex or a similar API-driven service

That hands-on list is the difference between “I read about it” and “I can answer scenario questions quickly.”

Final week and exam-day tactics for Cisco’s style

In the last week, stop trying to learn entirely new areas unless you have a major gap. Shift to consolidation.

Final week priorities

Review HTTP methods, status codes, auth types, and headers daily
Revisit Cisco platform differences: DNA Center vs Meraki vs Webex vs ACI vs UCS
Drill RESTCONF/NETCONF/YANG distinctions
Review Python snippets and JSON parsing patterns
Do mixed timed sets, then analyze mistakes by domain

Make a one-page cram sheet for:

HTTP verbs and codes
Auth methods
Data formats and where they show up
Cisco platform purpose and API style
Automation tool distinctions

During the exam

Cisco exams reward careful reading. Watch for one-word pivots:

create vs update
partial update vs replace
authentication vs authorization
controller-based vs device-based
polling vs webhook

When you do not know an answer immediately, eliminate by category:

Is this asking about transport/protocol?
Is it testing API behavior?
Is it really a Cisco platform identification question?
Is it about security/auth?
Is it a networking fundamentals issue dressed up in software language?

That method works well on DEVASC because distractors often come from adjacent domains.

Time management

Do not spend too long on any one item early. This exam includes many questions you can answer quickly if your fundamentals are solid. Bank those points first.

Last honest advice

The people who pass most comfortably are the ones who combine three things:

Blueprint-driven study
Real API practice
Enough networking knowledge to understand the infrastructure context

If you do only one of those, the exam feels inconsistent. If you do all three, the questions start to look familiar. That is where you want to be before you sit cisco-200-901.