Cisco 350-901 AUTOCOR Exam Guide: What You Need to Know About the CCNP Automation Core Exam

What Is Cisco 350-901 AUTOCOR?

350-901 AUTOCOR v2.0 is Cisco’s core network automation exam. According to Cisco, it evaluates knowledge of network automation system development and design, with major emphasis on Infrastructure as Code, operations, and AI-assisted automation.

Passing AUTOCOR currently earns the Cisco Certified Automation Specialist – Core certification. It also satisfies the core examination requirement for both:

• CCNP Automation
• CCIE Automation

For CCNP Automation, AUTOCOR is combined with an eligible concentration exam. For CCIE Automation, it is followed by the CCIE Automation practical exam.

You can think of AUTOCOR as the point where traditional network engineering starts merging seriously with software engineering, DevOps, SRE practices, and modern infrastructure automation.

If you are currently researching the certification path, exam scope, or preparation resources, this 350-901 AUTOCOR exam resource can also be useful as a companion reference while building your study plan.

Official exam information is available on the Cisco 350-901 AUTOCOR exam page.

DEVCOR vs. AUTOCOR: What Changed?

Older study material frequently refers to 350-901 DEVCOR, or Developing Applications Using Cisco Core Platforms and APIs. That was the core exam associated with Cisco Certified DevNet Professional.

Cisco has since reorganized its automation certification program. Effective February 3, 2026, the DevNet certification naming structure transitioned to the more familiar Cisco career-certification model:

• DevNet Associate became CCNA Automation
• DevNet Professional evolved into CCNP Automation
• DevNet Expert became CCIE Automation

The Professional-level change was more than cosmetic. AUTOCOR v2.0 places much stronger emphasis on the practical engineering of automation systems. The current blueprint focuses heavily on Infrastructure as Code, CI/CD, testing, operations, security, and AI-assisted automation.

So if you find a DEVCOR video course, book, or study repository, do not automatically assume it maps to the current exam. Some fundamentals are still useful, especially APIs, Python, Git, and Cisco programmability, but you should always compare the material against the latest AUTOCOR v2.0 blueprint.

Cisco 350-901 AUTOCOR Exam Details

Before scheduling the test, candidates should review the latest Cisco policies and make sure their preparation materials match the current 350-901 AUTOCOR exam rather than the older DEVCOR version.

Exam policies, pricing, delivery options, and available languages can change, so verify logistics on Cisco’s official site before scheduling your test.

350-901 AUTOCOR v2.0 Exam Blueprint

The current blueprint is divided into four domains:

Those percentages tell us something important about the philosophy of the exam. Only half of the blueprint is what many beginners might call “automation tools.” The other half is about running automation reliably and incorporating modern AI capabilities safely.

In other words, Cisco is testing automation as an engineering discipline, not merely as a collection of scripts.

When reviewing your preparation progress, it is useful to compare these four domains against a structured Cisco AUTOCOR exam preparation resource so that weaker areas are easier to identify.

Domain 1: Network Automation — 30%

The first domain covers several different ways of controlling network infrastructure programmatically.

You should be comfortable thinking about the same network change from multiple perspectives. For example, suppose you need to create VLANs or modify interface configurations across a fleet of devices. Depending on the environment, that task might be implemented with:

• Python
• Ansible
• Terraform
• RESTCONF
• A platform REST API

AUTOCOR is interested not only in whether you know these tools, but also whether you understand when one approach makes more sense than another.

Python for Network Automation

Python remains foundational because it gives you direct control over data processing, APIs, authentication, error handling, logging, and workflow logic.

A simple automation script might make an API request, inspect the response code, convert JSON into a Python object, modify data, and send another request.

import requests

url = "https://network-controller.example/api/devices"

headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Accept": "application/json"
}

response = requests.get(
    url,
    headers=headers,
    timeout=10
)

response.raise_for_status()

devices = response.json()

for device in devices:
    print(device["hostname"])

The syntax itself is not the difficult part. The more important questions are operational:

• What happens if authentication expires?
• How do you deal with HTTP 429 rate limiting?
• What if an API paginates after 100 objects?
• Where should credentials be stored?
• What does the script log when something fails?
• Can it safely be run twice?

That is closer to the mindset AUTOCOR expects.

REST APIs

You should know the basic HTTP methods such as GET, POST, PUT, PATCH, and DELETE, but AUTOCOR goes beyond memorizing verbs.

The blueprint explicitly calls out more realistic API behavior, including:

• Pagination
• Complex authentication workflows
• Persistent authentication
• Rate limiting
• Error handling

If your only API practice has been copying a GET request into Postman, spend more time building actual workflows.

YANG and RESTCONF

YANG is a modeling language used to describe structured network configuration and operational data. RESTCONF provides an HTTP-based interface for interacting with data represented by models such as YANG.

For beginners, the important conceptual chain is:

YANG model → structured network data → RESTCONF request → device configuration or state

Do not treat YANG as something to memorize line by line. Learn how to navigate a data model and translate the relevant hierarchy into a JSON or XML payload.

Ansible

Ansible gives network engineers a declarative and relatively accessible way to automate configuration tasks. AUTOCOR expects you to understand how an Ansible-based solution could manage items such as VLANs, interfaces, ACLs, OSPF, and asset information.

You should understand concepts including:

• Inventories
• Playbooks
• Variables
• Tasks
• Modules and collections
• Idempotency
• Templates
• Error handling

Terraform

Terraform is another major technology in the blueprint, but its operating model is different from a traditional configuration script.

Terraform describes desired state. Providers interact with an API or platform, and Terraform keeps track of managed resources through its state mechanism.

For network engineers, the useful mental model is:

Code describes what infrastructure should look like; Terraform works out what needs to change.

You should understand resources, providers, variables, plans, state, and the consequences of configuration drift.

Domain 2: Infrastructure as Code — 30%

This is arguably the most important domain for students coming from a traditional networking background because it requires a change in operating philosophy.

Infrastructure as Code, or IaC, means that infrastructure configuration is treated like software: stored in version control, reviewed, tested, validated, and deployed through repeatable processes.

Git Is Not Optional

For AUTOCOR, knowing git add, git commit, and git push is not enough.

The official blueprint includes operations such as:

• Merging branches
• Squashing commits
• Resolving merge conflicts
• git cherry-pick
• git reset
• git checkout
• git revert

The best way to learn these commands is to intentionally break a small repository. Create conflicting branches. Commit something you did not want. Revert it. Reset it. Cherry-pick a change from another branch.

Git makes much more sense after you have recovered from a few self-created disasters.

GitLab CI/CD

A modern automation system should not depend on an engineer manually launching a Python script from a laptop.

The AUTOCOR blueprint expects candidates to understand GitLab CE CI/CD pipelines and a workflow containing stages such as:

1. Build
2. Prevalidation
3. Deploy
4. Post-validation

That sequence is worth understanding deeply.

Consider a proposed routing change. A reasonable automated workflow might first check syntax, launch a lab topology, validate the intended change, deploy it, and then perform another series of tests to verify that reachability and routing behavior are still correct.

Now compare that with the traditional workflow of logging into a router and pasting commands.

That difference is essentially what modern NetDevOps is about.

Cisco Modeling Labs

Cisco Modeling Labs (CML) can be integrated into automation workflows so that network changes are tested against simulated network devices before being pushed into production.

This is an important concept because the objective is not simply “automate faster.” Bad automation also makes mistakes faster.

The better objective is:

automate changes while increasing repeatability, testing, and confidence.

Source of Truth

A scalable automation environment needs an authoritative source describing what the network should contain.

That source of truth might include information such as:

• Device inventory
• IP addressing
• Sites
• Interfaces
• VLANs
• Roles
• Configuration intent

The important principle is that automation should not be based on a collection of inconsistent spreadsheets and values hard-coded inside scripts.

Docker Compose

The blueprint also expects candidates to interpret Docker Compose files, including services, networks, volumes, and links.

Why would a network automation engineer care about containers?

Because an automation solution is often more than one Python process. It may contain an API, database, worker, testing service, telemetry collector, or AI component. Containers provide a predictable way of packaging and running those dependencies.

Domain 3: Operations — 20%

This domain separates a lab script from an operational automation platform.

In production, the first question is not only, “Did the script work?” It is also:

“If it fails at 2:00 a.m., how will we know what happened?”

Model-Driven Telemetry

Traditional network monitoring often relies on periodic polling. Model-driven telemetry takes a more streaming-oriented approach, allowing network devices to publish structured operational data to collectors.

You should understand the architectural components involved in sending, collecting, and consuming telemetry data and why streaming telemetry can be useful for modern network observability.

Logging

The exam includes logging strategies involving destinations such as syslog and webhooks.

A useful automation log should answer questions such as:

• What action was attempted?
• Which device or API was involved?
• When did it happen?
• Did it succeed?
• If not, what exception or response was returned?
• Which change or pipeline triggered it?

Logging is not decorative output. In an automated environment, it becomes part of your troubleshooting interface.

pyATS and Change Validation

Cisco pyATS is especially relevant for network testing and validation.

Suppose an automation pipeline modifies OSPF configuration. After deployment, your validation process could check that:

• Expected OSPF neighbors are established
• Required routes are present
• Interfaces are in the expected state
• Reachability tests pass

This is a much stronger automation pattern than simply checking whether the configuration API returned HTTP 200.

A successful API response only tells you the request was accepted. It does not necessarily prove that the network is behaving correctly.

TLS Certificates

Automation systems communicate with APIs, web interfaces, controllers, repositories, and other services. AUTOCOR therefore includes the process of obtaining and deploying CA-signed TLS certificates.

Make sure you understand the relationship between:

• Private keys
• Certificate Signing Requests (CSRs)
• Certificate Authorities (CAs)
• Server certificates
• Certificate chains
• TLS trust

Secure Coding

An automation script often has access to powerful credentials and configuration interfaces. A security mistake in that code can therefore have a large blast radius.

The blueprint emphasizes areas including:

• Input validation
• Authentication
• Secret management

A password or API token should not be committed to Git simply because doing so makes the lab easier.

Domain 4: AI in Automation — 20%

This is the part of AUTOCOR v2.0 that makes the current exam noticeably different from many older network automation certifications.

AI in Automation accounts for 20% of the official blueprint. That is large enough that candidates should treat it as a core domain rather than an optional trend topic.

AI-Assisted Code Development

Large language models can accelerate tasks such as writing API clients, generating templates, explaining errors, and producing initial automation code.

But AUTOCOR also expects you to understand the risks.

Examples include:

• Incorrect generated code
• Hallucinated APIs or parameters
• Data privacy concerns
• Intellectual property considerations
• Credential exposure
• Insufficient code validation

This reflects an important engineering principle: generated code still needs testing and review.

AI Agents for Network Automation

An AI agent goes beyond simply asking an LLM to answer a question. The model can be connected to tools that retrieve network information or perform controlled operations.

For example, an engineer might ask:

“Which access switches currently have interfaces with unusually high error counters?”

An AI agent could potentially determine which network tool to invoke, retrieve structured telemetry or API data, process the result, and present a useful response.

MCP and FastMCP

The current AUTOCOR blueprint explicitly includes building an MCP server using Python FastMCP to provide network information to an AI agent.

MCP, or Model Context Protocol, provides a structured mechanism through which AI applications can interact with external tools and information sources.

For AUTOCOR preparation, focus on the architecture rather than treating MCP as another acronym to memorize:

LLM / agent → MCP interface → network tool or data source

You should also think seriously about authorization boundaries. An AI agent that can query interface status is one thing. An agent that can change production routing is quite another.

Evaluating AI Output

One of the most practical objectives in the blueprint is evaluating the accuracy of AI recommendations.

This is particularly important in networking because an answer that looks technically plausible can still be operationally dangerous.

If an AI model suggests changing a route policy, ACL, BGP attribute, or interface configuration, the engineer still needs a way to validate the recommendation against the actual network state and intended design.

Cisco Platforms Associated with AUTOCOR

The official AUTOCOR exam description references several Cisco technologies and platforms, including:

• Cisco IOS XE
• Cisco ACI
• Cisco Meraki
• Cisco Catalyst Center
• Cisco SD-WAN
• Cisco Identity Services Engine (ISE)
• Webex Messaging

You do not need to become the world’s leading expert in every platform before taking AUTOCOR. What matters is understanding how programmable infrastructure exposes APIs, data models, controllers, telemetry, and automation interfaces.

For a student, it is often better to understand one API workflow end to end than to memorize the names of fifty endpoints from five different Cisco products.

How Valuable Is the Cisco 350-901 AUTOCOR Certification?

The value of the Cisco AUTOCOR certification exam depends heavily on what you want to do with it.

For somebody targeting traditional entry-level help desk work, it is probably more specialized than necessary. For a network engineer moving toward automation, NetDevOps, platform engineering, or network SRE work, the skill set is far more relevant.

I would divide its value into three areas.

1. It Forces Network Engineers to Learn Modern Engineering Practices

Traditional networking skills remain important. You still need to understand addressing, routing, switching, security policy, and troubleshooting.

But large networks increasingly require engineers to manage infrastructure through APIs, automation frameworks, reusable data, source control, and testing pipelines.

AUTOCOR creates a structured reason to learn those practices.

2. It Connects Networking with DevOps

The combination of Git, CI/CD, Terraform, containers, validation, logging, and APIs gives the certification relevance outside a narrowly defined Cisco CLI role.

Those concepts are transferable. The exact API changes from platform to platform; good automation design changes much less.

3. It Provides a Path Toward CCNP and CCIE Automation

Passing the core exam is useful even before completing the full CCNP Automation track because Cisco awards the Automation Core Specialist credential for AUTOCOR itself.

It also gives candidates a direct foundation for continuing toward CCNP Automation or, at a considerably more advanced level, CCIE Automation.

What the Certification Does Not Do

A certification cannot replace actual engineering experience.

If two candidates both pass AUTOCOR, but one can also show a Git repository containing an automation project with tests, logging, documentation, and a CI pipeline, I would expect the project to generate the more interesting technical interview conversation.

The strongest combination is therefore:

certification + hands-on lab work + a small portfolio of automation projects.

Who Should Take Cisco AUTOCOR?

AUTOCOR makes sense for several types of learners:

• Network engineers who want to move beyond manual CLI operations
• CCNA or CCNP-level learners interested in automation
• Students interested in NetDevOps
• DevOps engineers who need stronger networking knowledge
• Network automation engineers
• Infrastructure engineers working with APIs and IaC
• Engineers interested in network SRE roles
• Candidates pursuing CCNP Automation
• Candidates eventually targeting CCIE Automation

It is technically possible to begin learning AUTOCOR topics without years of professional experience, but complete beginners should build fundamentals first.

What Should You Know Before Studying AUTOCOR?

Cisco’s AUTOCOR training does not list formal prerequisites, but Cisco recommends familiarity with several areas. In practical terms, I would want a new learner to have at least basic competence in the following:

• IPv4 addressing and subnetting
• VLANs and switching
• Routing concepts and OSPF basics
• ACL fundamentals
• Linux command line
• SSH
• Python fundamentals
• JSON and YAML
• REST APIs
• Git basics
• Basic YANG, NETCONF, and RESTCONF concepts
• Basic container concepts

If terms such as HTTP status code, JSON object, Git branch, VLAN, OSPF neighbor, and Docker container are all completely new to you, jumping immediately into AUTOCOR will probably create unnecessary frustration.

Build the foundation first. Automation becomes much easier when you understand both sides of the problem: the network and the software controlling it.

How I Would Study for Cisco 350-901 AUTOCOR

I would not study AUTOCOR one technology at a time in isolation. Instead, I would gradually build a small automation system and add exam technologies to it.

A good approach is to use the official blueprint as the source of truth and supplement it with labs, documentation, and a focused 350-901 Cisco AUTOCOR study resource when reviewing individual exam domains.

Phase 1: Strengthen Python and API Fundamentals

Start with:

• Python variables, lists, dictionaries, loops, and functions
• Virtual environments
• Reading and writing files
• JSON and YAML
• Exception handling
• Python requests
• HTTP methods and status codes
• Authentication

Write scripts yourself. Reading Python is easier than writing Python, and an exam or job eventually exposes that difference.

Phase 2: Learn Model-Driven Networking

Study the relationship among:

• YANG
• NETCONF
• RESTCONF
• JSON/XML payloads

Practice finding the data you want rather than memorizing models.

Phase 3: Automate the Same Task Multiple Ways

Choose one small objective, such as configuring an interface or VLAN, and attempt it with:

• Python
• RESTCONF
• Ansible
• Terraform where an appropriate provider is available

This teaches something textbooks often miss: every automation tool has strengths, limitations, and a different operating model.

Phase 4: Move Everything into Git

Do not keep scripts scattered around your Downloads folder.

Create a repository. Use feature branches. Generate merge conflicts. Practice reverting bad commits. Use cherry-pick, reset, and other blueprint operations until they stop feeling abstract.

Phase 5: Build a CI/CD Pipeline

Create a simple pipeline that:

1. Checks your code
2. Runs tests
3. Performs pre-change validation
4. Executes an automation change
5. Performs post-change validation

Even a small lab pipeline teaches more than memorizing a CI/CD diagram.

Phase 6: Add CML and pyATS

Use Cisco Modeling Labs or another suitable lab environment to test automation safely.

Then use pyATS or equivalent testing logic to verify that network state matches your expectations before and after a change.

Phase 7: Add Logging and Security

Refactor your scripts so they include:

• Useful logging
• Exception handling
• Input validation
• Environment-based or secure credential management
• TLS certificate validation

This is the point where the project starts looking less like a classroom script and more like an engineering tool.

Phase 8: Study AI Agents and MCP

Finally, experiment with a small AI-assisted network tool.

You do not need to give an LLM permission to configure your lab routers immediately. Start with read-only operations such as:

• Looking up device inventory
• Retrieving interface status
• Summarizing logs
• Explaining structured test results

Then study how MCP and FastMCP can expose those capabilities to an AI agent in a structured way.

A Practical AUTOCOR Lab Architecture

If I were building one lab specifically for this exam, I would try to make the individual topics interact with each other.

A simplified architecture could look like this:

Git Repository
      |
      v
GitLab CI/CD
      |
      +----> Python / Ansible / Terraform
      |
      +----> Pre-validation with pyATS
      |
      +----> Cisco Modeling Labs
      |
      +----> Network/API Change
      |
      +----> Post-validation with pyATS
      |
      +----> Logs / Telemetry
      |
      +----> AI Agent / MCP Tools

This type of project helps connect the blueprint into one mental model.

Instead of asking, “What is pyATS?” you begin asking, “Where should automated network validation occur in my deployment pipeline?”

That is a much more useful question.

Common Mistakes When Preparing for AUTOCOR

Mistake 1: Studying Only Python

Python is important, but Python alone will not cover a blueprint that gives 30% to Infrastructure as Code and another 40% combined to operations and AI.

Mistake 2: Memorizing API Definitions

Learn how to work with APIs rather than trying to memorize endpoint catalogs.

Authentication, pagination, error handling, data structures, rate limits, and workflow logic are more transferable skills.

Mistake 3: Ignoring Git Until the Last Week

Git operations become intuitive through repetition. They are surprisingly difficult to learn well from screenshots in a study guide.

Mistake 4: Treating CI/CD as Pure Theory

Build a pipeline. Even a tiny one.

Once you have watched a deployment fail because a test did not pass, the purpose of CI/CD becomes much clearer.

Mistake 5: Ignoring Network Fundamentals

Automation does not eliminate networking knowledge.

If a script is supposed to configure OSPF and you cannot recognize an incorrect OSPF design, automation simply allows you to deploy the wrong design more efficiently.

Mistake 6: Using Old DEVCOR Material as the Only Study Source

Some DEVCOR material remains useful, but the current AUTOCOR v2.0 blueprint contains major topics that older resources may not address adequately, particularly the current emphasis on IaC, operations, and AI.

When selecting preparation material, make sure the content specifically targets the current Cisco 350-901 AUTOCOR objectives rather than relying entirely on legacy DEVCOR resources.

Mistake 7: Learning AI as Vocabulary Only

Do not stop at memorizing LLM, agent, and MCP definitions.

Build something small. Give an agent access to a harmless read-only function. See how tool invocation works. Then deliberately test what happens when the model receives ambiguous or incorrect information.

Is AUTOCOR Difficult?

I would describe AUTOCOR as a broad exam rather than an exam dominated by one extremely difficult technology.

The challenge is that you have to move comfortably among several disciplines:

• Networking
• Programming
• APIs
• Infrastructure as Code
• Git
• CI/CD
• Testing
• Containers
• Security
• Network operations
• AI

A traditional network engineer may find Git, CI/CD, containers, and software practices difficult at first. A developer may find YANG, routing behavior, and network state validation unfamiliar.

That cross-disciplinary nature is also what makes the certification interesting.

AUTOCOR vs. CCNA Automation

Students who are completely new to network programmability should also be aware of CCNA Automation.

CCNA Automation is the associate-level entry point into Cisco’s current automation track, while AUTOCOR operates at the professional/expert core level.

If you already have solid networking fundamentals and some Python/API experience, moving directly toward AUTOCOR can be reasonable. If you are simultaneously learning basic networking, programming, APIs, Git, and automation concepts, the associate-level material may provide a smoother path.

Frequently Asked Questions About Cisco 350-901 AUTOCOR

What is the Cisco 350-901 exam called now?

The current exam is 350-901 AUTOCOR: Designing, Deploying and Managing Network Automation Systems.

Is 350-901 still DEVCOR?

No. DEVCOR was associated with the previous DevNet Professional certification structure. Cisco now uses 350-901 AUTOCOR as the Automation core exam.

What certification do I get after passing AUTOCOR?

Passing AUTOCOR earns the Cisco Certified Automation Specialist – Core credential. The exam also satisfies the core exam requirement for CCNP Automation and CCIE Automation.

How long is the 350-901 AUTOCOR exam?

Cisco currently lists the exam duration as 120 minutes.

How much does Cisco AUTOCOR cost?

Cisco currently lists the exam price as US$400, with Cisco Learning Credits also supported where applicable. Always confirm current pricing before scheduling.

How much Python do I need for AUTOCOR?

You should be comfortable writing practical Python automation rather than only understanding syntax. Focus on data structures, functions, exceptions, JSON/YAML, HTTP APIs, authentication, logging, input handling, and working with external libraries.

Does AUTOCOR include Terraform and Ansible?

Yes. Both Ansible and Terraform appear explicitly in the current AUTOCOR v2.0 blueprint.

Does AUTOCOR test Git?

Yes. Git is part of the Infrastructure as Code domain, including branching, merging, conflict resolution, cherry-pick, reset, checkout, and revert operations.

Is AI really part of the Cisco AUTOCOR exam?

Yes. AI in Automation represents 20% of the current blueprint. Topics include AI-assisted development risks, AI security, LLM-powered agents, MCP servers using Python FastMCP, and evaluation of AI recommendations.

Do I need hands-on labs?

For meaningful preparation, I strongly recommend them. AUTOCOR includes technologies that become much easier to understand after you have actually used them, especially Git, APIs, Ansible, Terraform, CI/CD, CML, pyATS, and MCP.

Where can I find additional 350-901 AUTOCOR preparation material?

In addition to Cisco’s official blueprint and documentation, you can review this 350-901 AUTOCOR preparation page as an additional reference when organizing your exam study and reviewing the certification objectives.

Is AUTOCOR worth taking for a student?

It can be, particularly if your goal is network automation, DevOps, infrastructure engineering, or network SRE work. However, students should avoid treating the certification as a replacement for networking fundamentals and hands-on projects.

Final Thoughts

Cisco 350-901 AUTOCOR represents a noticeable shift in what it means to be a network automation engineer.

The old mental model was often:

“Use Python to automate router commands.”

The modern model is much broader:

“Represent network intent as data and code, version it, test it, deploy it through controlled pipelines, validate the result, observe the system, secure the workflow, and use AI where it provides measurable value.”

That is a considerably higher bar, but it also makes the material much more relevant to real engineering environments.

If you are starting your AUTOCOR journey, resist the temptation to spend all of your time collecting notes. Build things. Break Git repositories. Write API clients. Create an Ansible playbook. Run a Terraform plan. Build a CI pipeline. Validate a network change with pyATS. Connect a small read-only network function to an AI agent.

At the same time, keep your preparation organized around the official exam domains and use a focused Cisco 350-901 AUTOCOR exam guide as a supplementary reference when you need to revisit specific areas.

The exam objectives make far more sense once you have seen the pieces working together.

And even if you eventually decide not to sit the 350-901 exam, those are skills worth having.

Official Cisco Resources

• Cisco 350-901 AUTOCOR Exam Page
  
• Cisco AUTOCOR Exam Topics
  
• Cisco CCNP Automation Exams and Training
  
• Cisco CCIE Automation Exams and Training
  
• Cisco AUTOCOR Training
  
• Cisco DevNet Developer Resources and Sandboxes
  

Editorial note: Cisco periodically updates certification exams and blueprints. Always compare your study plan with Cisco’s current official exam topics before scheduling the exam.