Automating and Programming Cisco Service Provider Solutions (300-535 SPAUTO) Exam Guide
Cisco designed 300-535 SPAUTO, Automating and Programming Cisco Service Provider Solutions, to validate implementation of automated service-provider solutions across programming concepts, orchestration, programmable operating systems, and automation tools. It serves candidates pursuing the Cisco Certified DevNet Specialist—Service Provider Automation and Programmability certification and professionals aligning it with CCNP Service Provider or Cisco Certified DevNet Professional pathways. The immediate decision is whether SPAUTO is still the right exam target: Cisco’s archived information lists February 2, 2026, as the last date to test, so confirm the current Cisco certification page before investing in a study plan or booking anything.
Confirm the exam is still the right target
The first preparation task is not technical study; it is status verification. Cisco’s exam-topics archive lists February 2, 2026, as the last date to test for SPAUTO, and that date is past as of August 18, 2026. Treat the supplied exam information as a reference for skills and historical planning, then check Cisco’s current certification pages for any replacement, successor, or updated pathway before scheduling. Source: https://learningnetwork.cisco.com/s/archive/spauto-exam-topics and https://www.cisco.com/site/us/en/learn/training-certifications/exams/spauto.html.
The exam is identified by Cisco as 300-535 SPAUTO, Automating and Programming Cisco Service Provider Solutions. Cisco states that passing it earns the Cisco Certified DevNet Specialist—Service Provider Automation and Programmability certification. The v1.1 exam-topics document also associates SPAUTO with the CCNP Service Provider and Cisco Certified DevNet Professional certifications. Those relationships make the exam relevant to more than one certification plan, but they do not by themselves establish that SPAUTO remains an available registration option.
Use this decision sequence: first inspect the live Cisco exam page; next compare its current certification requirements with your intended credential; finally confirm whether the v1.1 blueprint remains the applicable outline. Do not pay for a booking based only on an older training page, cached listing, or third-party catalogue entry. If Cisco identifies a successor exam, transfer the study topics only after comparing the successor’s official blueprint.
What SPAUTO validates
SPAUTO focuses on implementing automated solutions for service-provider environments rather than on isolated Python syntax or general software development. Cisco describes the exam as covering programming concepts, orchestration, programming operating systems, and automation tools. The practical target is the ability to connect those elements: choose an interface, work with a device data model, automate a change or retrieval task, and handle structured results appropriately. Source: https://www.cisco.com/site/us/en/learn/training-certifications/exams/spauto.html.
The v1.1 blueprint names technologies across both IOS XE and IOS XR automation. It includes Git, REST and RPC APIs, Python, virtual environments, and Ansible or Terraform. It also names YANG, HTTP authentication, JSON, XML, YAML, gRPC, protobuf, RESTCONF, NETCONF, and NETCONF datastore comparison. These topics point to an implementation-oriented assessment in which the relationship between a tool, protocol, data model, and operating system matters.
A candidate who can recite definitions but cannot explain when to use RESTCONF instead of NETCONF, or how a YANG model relates to structured configuration, has a preparation gap. Conversely, someone with strong service-provider operations experience should not assume that device familiarity replaces scripting, API, and data-format practice. Prepare the boundary between networking knowledge and software execution.
Who should consider this exam
SPAUTO is most suitable for a network engineer, automation engineer, developer, or service-provider specialist who already understands network operations and wants to implement programmable workflows. It is also relevant to candidates building a CCNP Service Provider or Cisco Certified DevNet Professional plan, because Cisco’s v1.1 document associates the exam with both certifications. The exam is less suitable as a first exposure to networking, Python, or structured APIs.
Cisco’s service-provider developer material frames automation around networking, virtualization, and software expertise, with IOS XR presented as an open and programmable operating system. The same resource describes model-driven interfaces for structured configuration and operational data. That context matters: the study target is not simply “learn a tool,” but learn how automation interacts with large-scale service-provider systems. Source: https://developer.cisco.com/service-providers/.
Use a skills inventory before choosing a course or lab. Rate yourself separately on Python, Git, HTTP and API concepts, YANG and data formats, IOS XE, IOS XR, Ansible or Terraform, and telemetry. Mark each area as can explain, can implement, or unfamiliar. Study time should go first to topics that are both heavily weighted and below the can implement level.
How to read the v1.1 blueprint
The v1.1 blueprint assigns 30 percent to Automation APIs and Protocols, 30 percent to Network Device Programmability, and 10 percent to Network Programmability Foundation. These are official domain labels and percentages, not general estimates. The two 30 percent domains deserve the largest share of hands-on work, while the 10 percent Network Programmability Foundation domain still requires deliberate review because foundational mistakes can affect every practical topic. Source: https://learningcontent.cisco.com/documents/marketing/exam-topics/300-535-SPAUTO-v1.1.pdf.
Network Programmability Foundation includes foundational implementation knowledge such as Git, REST and RPC APIs, Python, virtual environments, and Ansible or Terraform for IOS XE and IOS XR automation, according to the supplied v1.1 topic summary. Build a small reference sheet for request methods, authentication, payload formats, error handling, Python environment isolation, version control workflow, and the role of an automation runner.
Automation APIs and Protocols should be studied through comparisons rather than a vocabulary list. Connect RESTCONF and NETCONF to their transport and data-model expectations; distinguish JSON, XML, YAML, protobuf, and gRPC by where they appear in a workflow; and explain HTTP authentication at the point where a script establishes access. Network Device Programmability should then connect those protocols to IOS XE and IOS XR behavior, tools, models, and telemetry.
Do not infer that the three supplied percentages represent the complete blueprint or that a low percentage can be ignored. The official document is the authority for the full domain list and current weighting. Recheck the document directly if Cisco publishes a revision; the supplied research identifies the current document as version 1.1.
Build the technical foundation before automating devices
Start with a controlled Python and Git workflow before attempting multi-device automation. Create a virtual environment, keep dependencies separate from the system interpreter, initialize a Git repository, and commit small working changes. This sequence makes failures easier to isolate and gives you practice with the exact foundation topics named in the v1.1 blueprint.
Your first exercises should be deliberately small: parse a JSON response, load YAML configuration data, make a request to a documented API, inspect an HTTP status, and handle an unsuccessful response without silently treating it as success. Then write a Python function that accepts device or service parameters and produces a structured request. The goal is readable, repeatable behavior rather than a large script.
Review REST and RPC APIs as different interaction styles. For each, write down the operation being requested, the input structure, the output structure, and how the response signals failure. Add authentication to the exercise only after the unauthenticated request shape is clear. Never place real credentials in source control; use an approved local method for test credentials and remove them from shared files.
For Ansible or Terraform, learn the purpose of the tool in the workflow rather than memorizing isolated syntax. Ansible playbooks describe ordered automation tasks; Terraform is associated with declarative infrastructure management. The exam blueprint names Ansible or Terraform for IOS XE and IOS XR automation, so practice reading and adapting examples for both operating systems where your lab permits it.
Study APIs, models, and formats as one workflow
The most efficient way to learn the API material is to follow one modeled transaction from start to finish: identify the YANG model, select the protocol, authenticate, send structured data, inspect the response, and verify the device state. This exposes the decisions hidden by disconnected flashcards and helps distinguish protocol errors from model or payload errors.
YANG is not merely another serialization format. Treat it as the model that describes configuration and operational data, while JSON or XML represents data exchanged through an interface. YAML may describe automation input or task data, whereas protobuf is associated with a compact message definition used with gRPC. Keep these roles separate in your notes and lab observations.
Compare NETCONF and RESTCONF by operation, payload, datastore behavior, and response handling. The blueprint explicitly includes NETCONF datastore comparison, so study how candidate configuration and committed or running state differ in the workflow supported by the relevant platform. Do not rely on a generic explanation detached from IOS XE or IOS XR; record what the device and interface actually expose in your authorized lab.
HTTP authentication belongs in the transaction model. Practice identifying where credentials or tokens are supplied, how the client handles an authentication failure, and which information should be kept out of logs. A script that reaches the endpoint but mishandles authentication or response validation is not a reliable automation solution.
Use the official blueprint as a checklist, not as a promise that every named item will appear in an identical form. It names RESTCONF, NETCONF, gRPC, and protobuf, along with the formats and authentication concepts above. Your practice should therefore focus on transfer: explain the same automation intent through more than one supported interface when possible.
Connect tools to IOS XE and IOS XR tasks
Tool selection should follow the device interface and the job to be done. The v1.1 blueprint names ncclient, YDK with YANG Suite, Netmiko, Ansible playbooks, gNMI, RESTCONF scripting, XPath, and model-driven telemetry with gRPC for IOS XR. Study each tool in a small, observable workflow and record what it abstracts, what it requires, and how you verify its result.
Use Netmiko to understand device-session automation and the risks of relying on command output. Contrast that with model-based approaches in which structured data and YANG models define the intended interaction. With ncclient, examine how a Python client works with NETCONF operations and datastores. With RESTCONF scripting, inspect resource paths, payloads, authentication, and response codes rather than copying a complete script without understanding it.
YDK with YANG Suite deserves a separate study pass because the blueprint names both together. Learn how models and generated or assisted interfaces shape the request, then compare that experience with direct protocol use. The learning objective is not to prefer the most convenient tool in every case; it is to recognize the layers between a service intent, a model, a protocol, and a device operation.
For IOS XR, practice gNMI and model-driven telemetry with gRPC as a data-observation workflow. Identify the difference between retrieving a current value and receiving a stream of updates. Review how XPath can select the relevant portion of structured data. A useful lab record includes the subscription or query intent, the returned structure, the filtering expression, and the method used to verify that the result is meaningful.
Do not treat IOS XE and IOS XR as interchangeable labels. Keep a matrix showing operating system, interface, client or tool, data format, authentication method, and verification step. This matrix is more useful than a long list of commands because it forces you to make the cross-product decisions the blueprint is designed to test.
A practical six-stage study roadmap
A staged plan works better than switching randomly between Python, protocols, and device commands. Move from foundations to modeled interfaces, then to tool comparisons and telemetry. At the end of each stage, produce a small artifact that proves what you can implement; if you cannot produce it without copying a solution, keep the stage open rather than advancing by calendar alone.
Stage one: establish your baseline and environment. Verify the official exam status and applicable blueprint first. Then audit Python, Git, HTTP, data formats, and service-provider networking. Prepare a virtual environment and a repository for lab notes and code. Record platform access limitations immediately so you do not build a plan around an unavailable interface.
Stage two: strengthen Network Programmability Foundation. Write small Python programs that consume structured data, make an API request, validate a response, and report an error clearly. Practice Git branches or small commits, and create an Ansible playbook or Terraform exercise appropriate to your authorized IOS XE or IOS XR environment. Review REST and RPC concepts after each exercise by explaining the request in plain language.
Stage three: work through models and protocols. Build a YANG-centered comparison of NETCONF and RESTCONF. Include authentication, JSON and XML payloads, datastore behavior, and response validation. Add gRPC and protobuf to the comparison, then identify where they fit in a telemetry or API workflow. Keep examples sanitized and use only systems you are authorized to access.
Stage four: rotate through the named tools. Create a short lab for ncclient, YDK with YANG Suite, Netmiko, Ansible playbooks, gNMI, and RESTCONF scripting where your environment supports them. The output for every lab should include a goal, inputs, tool choice, expected result, observed result, and recovery step. This prevents tool familiarity from being confused with implementation competence.
Stage five: integrate by platform. Perform one IOS XE workflow and one IOS XR workflow, using model-driven interfaces where available. Add XPath filtering and a gRPC-based model-driven telemetry exercise for IOS XR if your lab supports it. Compare configuration automation with operational-data collection, because reliable changes and reliable observation require different verification habits.
Stage six: conduct readiness reviews. Close your notes and explain each blueprint topic, then implement a small workflow from a written requirement. Review failures by category: Python or environment, authentication, transport, payload or model, device behavior, and verification. Schedule only after the current Cisco page confirms that the exam is available and that the version you studied is applicable.
Use labs to test decisions, not just commands
A useful SPAUTO lab asks you to choose an approach and defend it. Give yourself a service-provider task, define the desired state and evidence of success, select a protocol and tool, then test failure handling. This is more valuable than running a copied command sequence because it exercises implementation judgment across the blueprint’s programming, API, operating-system, and orchestration themes.
For a configuration lab, begin with a harmless change in an isolated environment. Identify the relevant model or resource, prepare the payload, authenticate, submit the operation, and verify the resulting state through a separate read. Deliberately introduce one malformed field or invalid value, observe the response, and document whether the device changed. Never use production devices or unapproved credentials for this exercise.
For an operational-data lab, query or subscribe to a narrow data set instead of collecting everything. Use XPath where applicable to select the information you need, then check whether the returned values are current, correctly typed, and sufficient for the decision the automation must make. For model-driven telemetry with gRPC, distinguish a stream of updates from a one-time retrieval in your notes.
For orchestration, represent inputs separately from tasks and keep the workflow repeatable. Test what happens when a task runs twice, when one device is unreachable, and when a later task depends on an earlier result. The aim is to understand idempotence, ordering, error handling, and verification; do not claim a workflow succeeded merely because the automation tool completed without a visible exception.
Cisco’s service-provider developer resource includes material on model-driven interfaces, Crosswork Network Automation, Network Services Orchestrator, EPNM, WAE, and other service-provider automation contexts. Use that resource for architecture context, but do not substitute product browsing for the blueprint’s named implementation skills. Source: https://developer.cisco.com/service-providers/.
Common preparation mistakes
The most damaging mistake is preparing for an exam that is no longer schedulable without checking Cisco first. The supplied archive records a last test date of February 2, 2026. A second mistake is treating a third-party question bank or exam dump as a substitute for implementation practice. Memorization does not establish that you can build, troubleshoot, or verify an automated solution, and no source supports a claim that dumps guarantee a pass.
Another common error is studying protocols independently of data models. Memorizing that NETCONF, RESTCONF, or gNMI exists will not prepare you to select a model, form a valid request, interpret a response, or compare datastore behavior. Tie every protocol note to an actual payload, model path, operation, authentication step, and verification result.
Do not overinvest in Python syntax while neglecting service-provider behavior. Basic loops and functions are useful, but the blueprint connects Python with virtual environments, APIs, IOS XE, IOS XR, and automation tools. Spend less time solving abstract coding puzzles and more time writing small scripts that handle structured network data and failure responses.
Avoid tool collecting. Installing every named library without completing a workflow creates shallow familiarity and fragile notes. Choose a primary workflow, then compare alternatives against it. If a tool is unavailable in your lab, learn its documented role and interface boundaries from Cisco material, and do not present an untested personal procedure as an official requirement.
Finally, do not confuse a successful request with a successful change. Verify device state independently, inspect returned data, test a failure path, and preserve enough context to reproduce the result. These habits make study time productive even when the exact exam format or question wording is not known.
Delivery details to verify before booking
Cisco lists SPAUTO as a 90-minute exam and lists English and Japanese as available languages. Cisco also lists a U.S. price of $300 and states that Cisco Learning Credits are accepted. Because the supplied official archive records a past last-test date, treat these details as reference information and confirm them on Cisco’s live exam page before making a purchase or scheduling decision. Source: https://www.cisco.com/site/us/en/learn/training-certifications/exams/spauto.html.
The official page identifies the exam as 300-535 SPAUTO and describes its coverage as implementation of service-provider automated solutions. The page’s delivery and registration information is the proper source for any current appointment, policy, payment, or availability detail. This guide does not add unsupported assumptions about delivery mode, question count, scoring, prerequisites, retakes, or test-day procedures.
If you are considering Cisco’s SPAUI training, Cisco’s course description says it prepares learners for SPAUTO and awards 24 Continuing Education credits toward recertification. Training can provide structure, but it should be evaluated against your gaps: a course is most useful when it gives you practice with the blueprint topics you cannot yet implement independently. Source: https://www.cisco.com/c/dam/en_us/training-events/training/courses/spaui.pdf.
How to decide whether you are ready
Readiness should be demonstrated through implementation and explanation, not a percentage from an unofficial quiz. Before pursuing a currently available successor or replacement, you should be able to map a service-provider automation requirement to a suitable interface, data model, tool, and verification method, then explain what can fail at each layer.
Use a four-part review for every major topic. First, explain the concept without notes. Second, identify a realistic IOS XE or IOS XR use. Third, implement a small authorized lab workflow. Fourth, troubleshoot one deliberately introduced failure. Apply this to Git and Python environments, REST and RPC APIs, YANG, RESTCONF, NETCONF, gRPC and protobuf, Ansible or Terraform, and the named client and telemetry tools.
Give extra attention to the domains officially weighted at 30 percent: Automation APIs and Protocols and Network Device Programmability. Also complete the 10 percent Network Programmability Foundation material rather than treating it as optional. Keep the domain label attached to each review note so you do not accidentally use the 30 percent figures as unsupported comparisons with topics whose weights are not provided here.
You are ready to make a scheduling decision only after checking the live Cisco source, confirming the applicable version, and matching your preparation to that version. If the exam is unavailable, preserve the lab portfolio and use it to evaluate the official successor’s blueprint instead of attempting to book an archived target.
Recommended next actions
Start with verification, then convert the blueprint into evidence. Check Cisco’s current SPAUTO page and certification requirements; download or review the applicable official topics document; inventory your skills; and create a lab plan that gives the two 30 percent domains the most implementation time while still covering the 10 percent foundation domain.
Next, build one repository containing sanitized Python, Ansible or Terraform, API payloads, model notes, and lab results. Separate IOS XE and IOS XR examples. Add a comparison table for NETCONF, RESTCONF, gNMI, and gRPC, including data model, format, authentication, operation type, and verification method. Keep credentials and sensitive topology information out of the repository.
Finally, test yourself with requirements rather than recalled questions. Ask: Which interface fits this task? What model or resource identifies the data? What payload or message is required? How will authentication and errors be handled? How will the device state or telemetry result be verified? If Cisco confirms a current exam or successor, map these artifacts to its official blueprint and remove anything the new scope does not support.
Conclusion
SPAUTO preparation is best treated as a decision-and-implementation project: verify the exam’s current availability, confirm the applicable blueprint, then practice the complete path from service-provider requirement to model, protocol, tool, device interaction, and verification. The supplied v1.1 evidence emphasizes Automation APIs and Protocols and Network Device Programmability at 30 percent each, with Network Programmability Foundation at 10 percent, while the named technologies span Python, Git, YANG, RESTCONF, NETCONF, gNMI, gRPC, Ansible or Terraform, and IOS XE and IOS XR. Build evidence through authorized labs, not dumps or memorized claims, and use Cisco’s live pages for the final scheduling decision.
Related exams
- 300-510 exam — Implementing Cisco Service Provider Advanced Routing Solutions
- Implementing Cisco Service Provider VPN Services (300-515 SPVI)
- 300-540 exam — Designing and Implementing Cisco Service Provider Cloud Network Infrastructure (SPCNI)
- Implementing and Operating Cisco Service Provider Network Core Technologies (350-501 SPCOR)
