CCNA Automation Exam Prep · Browser-first course

CCNA Automation Exam Prep

Prepare for the 200-901 CCNA Automation exam in your browser.

45: lessons
9: modules
$299: every paid course, lifetime

Independent training by RouteSwitchU. Course publisher and trademark notice

Purchases pausedNew signups and purchases are temporarily paused for maintenance. Please check back later.Course content Try a graded lab first

It costs $299 once, and that one payment opens every paid course we sell, now and later. You keep them for the life of the site, and refunds are available for 14 days, no questions asked.

Learning objectives

What you will be able to do

Interpret HTTP status codes, headers, and response bodies.
Parse JSON, XML, and YAML into Python and work with the result.
Write a unit test and run it against code you wrote.

What you leave with

Why choose this course?

Topics across six exam domains
The course covers the six domains of the 200-901 exam. They are software development and design, APIs, Cisco platforms, application deployment and security, infrastructure and automation, and network fundamentals. The course covers every objective in Cisco’s published 200-901 blueprint, and the Knowledge Matrix shows which lesson covers each one.
Three capstones
Build an estate inventory report, carry out a simulated configuration change, and develop a nightly audit. Each capstone combines interpretation, implementation, and verification.
Drill decks for recall
Five decks provide repeated practice with platform names, protocols, tools, and other factual material introduced in the lessons.

Course content

Learning roadmap

45 lessons · 9 modules

Each lesson includes questions with explanations. Practice lessons also include graded browser labs. Exercises use simulated responses rather than live Cisco services.

1. Design and Software Development6 lessons
Study software development methods, design patterns, and Python modules. Compare JSON, XML, and YAML, then parse each format in Python. Apply version control operations and write a unit test.
- How Software Teams Work
- How Code Is Organized
- JSON, XML, and YAML Compared
- Parsing Formats into Python
- Git Operations
- Writing a Unit Test
2. APIs12 lessons
Construct API requests, interpret responses, and diagnose failures. Compare the Cisco platform APIs identified in the blueprint and practice with simulated responses in the browser labs.
- Interpreting an HTTP Response
- Consumption Limits
- API Styles and Webhooks
- Constructing a Request from Documentation
- Authentication Mechanisms
- Writing a Script with requests
- Diagnosing a Failed Call
- The Network Controller Platforms
- Compute, Collaboration, and Security Platforms
- Using a Cisco SDK
- Device and Client Inventory
- Webex Spaces and Messages
Capstone 1. The Estate Inventory Report1 lesson
Build an organization-wide inventory report in five stages. Authenticate, retrieve paginated device records directly and through an SDK, filter current clients, and assemble a report and message body. Diagnose an incorrect count despite successful HTTP responses.
- The Estate Inventory Report
3. Networking Fundamentals4 lessons
Apply networking fundamentals when interpreting automation data. Compare device identifiers, distinguish network planes and services, read topology diagrams, and diagnose application connectivity from the provided records.
- Addressing, Devices, and Services
- Planes and Ports
- Reading a Topology Diagram
- Diagnosing Application Connectivity
4. Automating the Infrastructure11 lessons
Compare controller and device management APIs, interpret YANG models, and construct RESTCONF requests. Read automation scripts, playbooks, and sequence diagrams, then distinguish simulation, testing, and code review.
- Controller-Level and Device-Level Management
- On-Box APIs on IOS XE and NX-OS
- Constructing a RESTCONF Request
- Reading RESTCONF and NETCONF Output
- Reading a YANG Model
- Infrastructure as Code and the Tool Landscape
- Reading an Ansible Playbook
- Reading a Bash Script
- Identifying the Workflow in a Python Script
- Reading a Sequence Diagram
- Simulation, Testing, and Code Review
Capstone 2. The Change Window1 lesson
Carry out a simulated switch change in five stages. Derive the request count from a sequence diagram, check the specified interface, apply a RESTCONF change, and verify configuration and operational state. Diagnose an unintended uplink change and reverse it.
- The Change Window
5. Application Deployment and Security4 lessons
Compare application deployment models and containers, interpret a Dockerfile, and distinguish continuous integration, delivery, and deployment. Examine credential handling and the application security risks identified in the blueprint.
- Where Applications Run
- Reading a Dockerfile
- CI/CD and DevOps
- Application Security
Capstone 3. The Nightly Audit1 lesson
Develop a nightly interface audit in five stages. Define a fault from operational data, test that rule, interpret the container image and delivery pipeline, and supply a runtime credential. Diagnose why successful pipeline runs produced reports that missed a failed link.
- The Nightly Audit
Drills5 lessons
Revisit factual questions from the lessons across five decks: platforms and products, ports and services, API exchanges, software tools, and deployment and security. Use the decks for retrieval practice over time.
- Drill 1. Platforms and Products
- Drill 2. Addressing, Ports, and Services
- Drill 3. Formats and the API Exchange
- Drill 4. Software Practice and Tooling
- Drill 5. Where Code Runs, and Security

About this course

CCNA Automation Exam Prep

The exam used to be called DevNet Associate (200-901 DEVASC), and its number did not change. Study network automation through lessons and exercises using fixed example data. The course requires no Cisco account, sandbox reservation, or software installation. Its 9 curriculum sections include lessons across the six exam domains, three applied capstones, and five decks for retrieval practice.

Who it is for

Who should take this

For network engineers preparing for the 200-901 exam or developing the automation skills it assesses.

Requirements

What you need before you start

A current browser. No Cisco account or sandbox reservation is required.
Read and edit Python variables, strings, lists, dictionaries, loops, functions, imports, file reads, and basic exception handling. The free Python Foundations course teaches these skills; the optional check below links to specific practice.

Plan your study across the exam objectives

Use the Study Workspace to connect objectives with course lessons and identify practice limits. A free account saves your ratings, notes, resources, and study plan across devices. Return to your workspace from the course sidebar.

Who publishes this course

This is an independent course, not a Cisco course

This course is independent study material. RouteSwitchU is not a Cisco Learning Partner, and this course is not produced, reviewed, sponsored, or endorsed by Cisco. We cannot issue a Cisco certification and we do not administer Cisco exams. Cisco, CCNA, DevNet, Catalyst, and Cisco IOS XE are trademarks or registered trademarks of Cisco Systems, Inc. and/or its affiliates.

Full trademark attribution

Before the coding lessons

Find your Python starting point

This optional check helps you choose practice before the CCNA coding lessons. Predict each result before opening its explanation. It does not measure exam readiness or restrict entry. Networking concepts, HTTP, API libraries, and unit testing are taught in the CCNA course.

If all the examples are unfamiliar, start with your first Python script and follow the course navigation. If one skill needs work, use its link.

What does this display? Does the original text change?
```
raw = "  SW1  "
clean = raw.strip().lower()
print(clean)
```
Check the text result
It displays sw1. Each string method returns new text; raw keeps its spaces and uppercase letters. Review string methods.
Which hostname does this display, and what does the zero select?
```
devices = [{"hostname": "sw1"}, {"hostname": "sw2"}]
print(devices[0]["hostname"])
```
Check the data lookup
It displays sw1. Zero selects the first list entry; the named key then selects a value from that dictionary. Review list indexing and dictionary lookup.
What value comes back from the function? What changes if return becomes print?
```
def clean(raw):
    return raw.strip()

result = clean(" sw1 ")
print(result)
```
Check the function result
The function returns sw1, which is stored in result. Replacing return with print displays the text inside the function but leaves result as None. Review functions, calls, and return values.
Which values reach the result? Why is the empty list created before the loop?
```
selected = []
for vlan in [10, 200, 30]:
    if vlan < 100:
        selected.append(vlan)
print(selected)
```
Check the loop result
The result is [10, 30]. The loop checks every value; only values below 100 are appended. Creating the list once preserves earlier matches. Review loops and filtering.

Before the API coding labs, also practice file reads, exceptions, and imports. Inheritance, advanced regular expressions, and package construction are not entry requirements.

From inside the course

Diagnosing a Failed Callexam topic 2.5

reads_the_reason_a_request_was_rejectedtells_a_dead_credential_from_a_bad_requestrecognises_a_missing_scoperetries_long_enough_for_a_transient_outagecaptures_the_request_id_for_an_escalationnotices_a_filter_that_was_ignored

This lab gives you six API calls that have already failed. Your code figures out what kind of failure each one is, and the grader runs these six checks against it.

Graded lab - 6 checks, run right here

"""Page 2.7, diagnosing a failed call.

This lab presents six request outcomes. For each one, inspect the response
to distinguish the cause of the failure from its symptoms and identify an
appropriate response. The functions correspond to the six rows in the
lesson's diagnostic table.

The base URL, API key, and organization ID are provided below.
"""

import requests

BASE_URL = "https://meraki.example.com/api/v1"
API_KEY = "0123456789abcdef0123456789abcdef01234567"
ORG_ID = "549236"

HEADERS = {"X-Cisco-Meraki-API-Key": API_KEY}
ORG_URL = f"{BASE_URL}/organizations/{ORG_ID}"


def bad_query_message():
    """Return the error message from a request with perPage set to 5000.

    Request 5000 results per page from the devices endpoint. The response has
    status 400 and a body that explains the invalid request. Return its single
    error message.

    Returns: a string.

    Example:
        One sentence, lifted out of the error body:

            "networkId is not a valid identifier"

        That is the shape. The real message names a different problem.
    """
    raise NotImplementedError


def revoked_key_message():
    """Return the error message from the licenses endpoint.

    The supplied key is well formed and appears in the required header, but
    this request still fails. Return the response message explaining why.

    Returns: a string.

    Example:
        Same shape as the last one, one sentence:

            "The requested resource is not available"

        Return the message the body carries, not the status code and not
        the whole body.
    """
    raise NotImplementedError


def claim_status():
    """POST to the device claim endpoint and return the status code.

    The credential and endpoint path are valid. Inspect the response to
    identify the remaining cause of failure.

    Returns: an integer status code.

    Example:
        Three digits, the number itself:

            400

        Not the Response object. Which number you get is the exercise.
    """
    raise NotImplementedError


def transient_probe_attempts():
    """Count the attempts required for the transient probe to succeed.

    Call the devices endpoint with probe=transient until it returns status
    200. Count every call, including the successful one. Between attempts,
    wait for the interval specified by Retry-After. Limit the sequence to six
    attempts so that a persistent failure cannot cause an indefinite loop.

    Returns: an integer.

    Example:
        A small count, the successful call included:

            2

        So a probe that worked first time returns 1, never 0.
    """
    raise NotImplementedError


def persistent_request_id():
    """Return the X-Request-Id header from the persistent failure response.

    Call the devices endpoint with probe=persistent. This simulated failure
    persists across retries. Return the X-Request-Id response header so that
    the request can be identified during support investigation.

    Returns: a string.

    Example:
        The opaque id off the header, on its own:

            "4b19c0de77"

        Not the whole headers dict, and not the response body.
    """
    raise NotImplementedError


def filtered_device_count():
    """Return the device count from a request filtered by model.

    Request model=MS130-48 from the devices endpoint. Return len() of the
    response list. The request completes without an HTTP error; compare its
    result with the inventory to determine whether the filter was applied.

    Returns: an integer.

    Example:
        A plain count:

            3

        Then count how many devices in the estate really are that model,
        and see whether the two numbers agree.
    """
    raise NotImplementedError

Choose Run checks to grade this code in your browser. The first run downloads the Python runtime (~10 MB), so give it a few seconds.

Answer

"""Reference solution for page 2.7."""

import time

import requests

BASE_URL = "https://meraki.example.com/api/v1"
API_KEY = "0123456789abcdef0123456789abcdef01234567"
ORG_ID = "549236"

HEADERS = {"X-Cisco-Meraki-API-Key": API_KEY}
ORG_URL = f"{BASE_URL}/organizations/{ORG_ID}"
DEVICES_URL = f"{ORG_URL}/devices"


def bad_query_message():
    """Return the error message from a request with perPage set to 5000."""
    r = requests.get(DEVICES_URL, headers=HEADERS, params={"perPage": "5000"})
    return r.json()["errors"][0]


def revoked_key_message():
    """Return the error message from the licenses endpoint."""
    r = requests.get(f"{ORG_URL}/licenses", headers=HEADERS)
    return r.json()["errors"][0]


def claim_status():
    """POST to the device claim endpoint and return the status code."""
    r = requests.post(f"{DEVICES_URL}/claim", headers=HEADERS)
    return r.status_code


def transient_probe_attempts():
    """Count the attempts required for the transient probe to succeed."""
    for attempt in range(1, 7):
        r = requests.get(DEVICES_URL, headers=HEADERS, params={"probe": "transient"})
        if r.status_code == 200:
            return attempt
        time.sleep(int(r.headers.get("Retry-After", 1)))
    return 0


def persistent_request_id():
    """Return the X-Request-Id header from the persistent failure response."""
    r = requests.get(DEVICES_URL, headers=HEADERS, params={"probe": "persistent"})
    return r.headers["X-Request-Id"]


def filtered_device_count():
    """Return the device count from a request filtered by model."""
    r = requests.get(DEVICES_URL, headers=HEADERS, params={"model": "MS130-48"})
    r.raise_for_status()
    return len(r.json())

One payment opens this course and every other one

You pay once, and that opens this course and every other paid course we sell, now and later. You keep them for the life of the site, and refunds are available for 14 days, no questions asked.

Open the day you buy:

CCNA Automation Exam Prep (this course) · 45 lessons
Python Foundations for Network Engineers · 10 lessons, free with an account
AI-Assisted Network Automation · 35 lessons
Cisco Wireless Advanced Technologies Class · 20 lessons
Network FDE 101 · 4 lessons, free with an account
SONiC for Cisco Engineers · 4 lessons, free with an account
Cisco Quantum Readiness (PQC) · 21 lessons
Wireline for Network Engineers · 9 lessons
Power for Network Engineers · 34 lessons

The courses marked Coming soon on the courses page open to you when each one is released, at no extra cost.

Have a promotion code? You can type it on the checkout page, which shows your total before you pay.

Did you save a spot before we opened? Your $249 price holds until Thursday, October 8, at 9:00 AM Mountain Time. Buy with the link in your email, or ask for it on the saved-spot page.

Purchases pausedNew signups and purchases are temporarily paused for maintenance. Please check back later.

Prices in US dollars. Tax is added at checkout where it applies.

Your privacy choices

CCNA Automation Exam Prep

What you will be able to do

Topics across six exam domains

Three capstones

Drill decks for recall

Learning roadmap

Find your Python starting point

One payment opens this course and every other one

Network Engineering Courses