300-535 SPAUTO exam guide: status, skills, and preparation choices
300-535 SPAUTO validated the implementation of automated service-provider solutions using programming concepts, orchestration, operating systems, and automation tools. It was aimed at professionals building or supporting programmable service-provider environments and was associated with CCNP Service Provider and Cisco Certified DevNet Professional. The first decision is no longer how to schedule it: Cisco lists February 2, 2026, as the last date to test, so this guide helps former candidates and automation practitioners use the published blueprint intelligently rather than plan an unavailable attempt.
Confirm the exam is no longer available before investing in preparation
Cisco lists February 2, 2026, as the last date to test for 300-535 SPAUTO, and that date is past in the supplied research snapshot dated August 18, 2026. Do not buy training, request budget, or build a study calendar on the assumption that a SPAUTO appointment can still be booked.
That retirement date changes the useful purpose of this material. Use the v1.1 exam topics as a structured skills inventory if you previously held the specialist credential, are moving into service-provider automation work, or need to identify gaps in Python, model-driven interfaces, and IOS XE or IOS XR automation. For a new Cisco certification path, verify Cisco’s current offerings directly before choosing a replacement exam; this research does not establish which alternative, if any, replaces SPAUTO.
The published blueprint remains valuable, but it is not evidence of a future relaunch. A common planning mistake is treating an archived certification page or a retained exam-topics PDF as proof of availability. Separate the question of what the exam measured from the separate question of what Cisco currently offers.
What SPAUTO was designed to validate
Cisco described SPAUTO as an implementation-focused exam for service-provider automated solutions, spanning programming concepts, orchestration, programming operating systems, and automation tools. The emphasis was not simply knowing API terminology; candidates needed to connect structured data, interfaces, scripts, and automation workflows to network-device tasks.
The official title was Automating and Programming Cisco Service Provider Solutions. Cisco also stated that passing SPAUTO earned the Cisco Certified DevNet Specialist—Service Provider Automation and Programmability certification. The v1.1 blueprint associated the exam with both CCNP Service Provider and Cisco Certified DevNet Professional, which helps explain its combined networking and software orientation.
For skills development, that combination suggests a practical standard: be able to read an interface or data model, choose an appropriate method of interaction, produce or assess automation logic, and reason about the result on IOS XE or IOS XR. This is a better preparation target than collecting isolated command examples or memorizing product names.
Who benefits from the published blueprint now
The blueprint is most useful to service-provider network engineers and automation practitioners who need an organized map of Cisco-oriented programmability skills, even though the test window has ended. It is less useful as a starting point for someone who has not yet established basic networking and scripting habits.
A network professional can use it to shift from manual, one-device-at-a-time work toward repeatable interactions with structured configuration and operational data. A developer entering a network team can use it to identify the networking-specific concepts that sit around an API call: models, datastores, device operating systems, and telemetry. A team lead can use the categories as a conversation framework when identifying development objectives for engineers.
Practical recommendation: choose one role-relevant outcome before studying. For example, an IOS XR-focused engineer might prioritize model-driven telemetry and gRPC, while an engineer maintaining mixed automation workflows might start with Python, virtual environments, version control, and a configuration-management approach. The official blueprint identifies the technologies; your job responsibilities should determine the order in which you deepen them.
Use the published weighting without over-reading it
The supplied v1.1 blueprint facts assign 10 percent to Network Programmability Foundation, 30 percent to Automation APIs and Protocols, and 30 percent to Network Device Programmability. These weights make API and protocol work plus device programmability the clearest high-priority areas among the verified domains.
Network Programmability Foundation at 10 percent should still be learned first, not left until the end. Git, Python, virtual environments, REST and RPC API concepts, and Ansible or Terraform for IOS XE and IOS XR automation provide the working vocabulary required to make the larger domains meaningful. Skipping those foundations often produces fragile study: a learner can recognize a protocol name but cannot explain how a script is organized, isolated, reviewed, or safely reused.
Automation APIs and Protocols at 30 percent calls for active familiarity with YANG, HTTP authentication, JSON, XML, YAML, gRPC, protobuf, RESTCONF, NETCONF, and NETCONF datastore comparison. Rather than making disconnected flashcards, group these by the problem they solve: data representation, authentication, model-driven configuration or retrieval, remote procedure interaction, and state comparison.
Network Device Programmability at 30 percent brings the concepts closer to implementation. The verified blueprint includes ncclient, YDK with YANG Suite, Netmiko, Ansible playbooks, gNMI, RESTCONF scripting, XPath, and model-driven telemetry with gRPC for IOS XR. Practice should therefore require a learner to interpret inputs and outputs, not merely recall which library or protocol exists.
Do not manufacture a complete score model from the three verified weights. The official v1.1 document should be the reference for the full objective list. For ongoing development, use the confirmed weights as prioritization signals rather than as a substitute for reading each published objective.
Build the technical foundation in the right order
Start by making structured data and basic Python behavior routine, then move to model-driven interfaces and automation frameworks. This sequence reduces a frequent failure mode: attempting complex network automation before you can reliably inspect payloads, manage dependencies, or trace a request and response.
First, work with JSON, XML, and YAML as data you can read, validate, and transform. The objective is not to declare one format superior; it is to identify the structure, locate the needed value, and anticipate how a tool will consume or return it. XPath belongs in this phase because it gives a deliberate way to navigate modeled XML data rather than treating every response as unstructured text.
Next, establish a disciplined Python workspace with virtual environments and Git. A useful exercise is a small script with configuration separated from code, clear handling for unsuccessful interactions, and a Git history that explains meaningful changes. This is a practical recommendation, not a claim about a specific test task, but it reinforces the Python, virtual-environment, and Git knowledge named in the blueprint.
Then study YANG before trying to automate every interface. A model tells you how data is organized and constrained; NETCONF, RESTCONF, gNMI, and related tools are ways of working with that data. Candidates who jump directly to request syntax commonly struggle when a path changes, a payload is malformed, or returned data has a nesting level they did not expect.
Only after that foundation should you rotate through tools such as ncclient, YDK with YANG Suite, Netmiko, Ansible playbooks, and RESTCONF scripting. Compare their interaction style and required inputs in a lab or approved learning environment. The important habit is to justify the tool choice against the automation task, rather than forcing every task through a favorite library.
Turn protocol names into working decisions
API and protocol preparation is strongest when every technology is tied to an observable decision: what data is needed, how it is modeled, how access is authenticated, how state is changed or retrieved, and how the outcome is checked. The v1.1 blueprint’s coverage supports this connected approach.
For NETCONF, study the significance of datastores and practice explaining a comparison between them in clear language. A datastore comparison is not just terminology to memorize; it informs whether intended, candidate, running, or other available state aligns with expectations. Keep your explanation confined to the model and environment you actually have rather than assuming all platforms expose identical behavior.
For RESTCONF, combine HTTP authentication with the model and representation being used. A learner should be able to read a request path, identify the likely role of JSON or XML in the exchange, and inspect a response for the structured field that answers the original question. REST and RPC API concepts should be learned alongside this work because an API interaction has both transport-level and operation-level meaning.
For gRPC and protobuf, focus on their relationship to defined data and service interfaces. Pair that work with model-driven telemetry with gRPC for IOS XR, which the blueprint explicitly includes. A sound practice exercise is to define the operational question first, then identify the modeled information and telemetry mechanism needed to answer it. Avoid treating telemetry as merely another configuration channel.
gNMI, XPath, and YANG are especially easy to isolate in notes. Resist that approach. Put them into a short workflow: identify modeled data, select the relevant path, retrieve or subscribe through the appropriate interface, and verify the received structure. Even when no live device is available, annotated sample data and carefully documented expected outcomes can build the reasoning habit.
Create a practical skills roadmap
A useful SPAUTO-derived roadmap has four stages: foundations, models and interfaces, automation implementation, and verification. Move forward only when you can explain the output of your work and identify what would make it fail.
In the foundations stage, cover Python, virtual environments, Git, JSON, XML, YAML, REST concepts, and RPC concepts. Keep a personal reference that records what each data format looks like, how your environment is activated, and how changes are tracked. This is not busywork: it prevents environment and data-handling errors from being confused with network or protocol problems.
In the models and interfaces stage, study YANG, NETCONF, RESTCONF, HTTP authentication, XPath, gRPC, protobuf, and gNMI. Create small comparison notes organized by purpose rather than by alphabet: model definition, configuration or operational interaction, data navigation, and streaming or remote service communication. Revise those notes when you find an exception in a controlled exercise.
In the implementation stage, use the blueprint’s named tooling to build narrowly scoped workflows. For instance, write one RESTCONF scripting exercise, one ncclient-oriented exercise, one Netmiko-oriented interaction, and one Ansible playbook review or build. Include IOS XE and IOS XR where your available authorized environment permits. The goal is transferable judgment about inputs, outputs, and error conditions, not volume of scripts.
In the verification stage, deliberately inspect before-and-after state and telemetry output. Ask what proves a request reached the intended target, what proves the returned data is the right modeled object, and what evidence distinguishes an authentication issue from a payload, path, or transport issue. This stage consolidates NETCONF datastore comparison and model-driven telemetry topics into habits that matter beyond certification.
Avoid preparation traps that waste effort
The main preparation risk is passive recognition: knowing that NETCONF, RESTCONF, gNMI, Ansible, and Netmiko are on the blueprint without being able to reason through a small automation workflow. Replace broad reading sessions with short, explainable exercises that produce structured input, an action or query, and a result to inspect.
Do not start with a large end-to-end orchestration build. Large projects hide basic gaps in authentication, data models, payload structure, Python environments, and version control. Begin with one request, one response, and one explicit validation point; add automation layers only after you can diagnose the smaller workflow.
Do not treat IOS XE and IOS XR as interchangeable labels. The official blueprint explicitly names automation for IOS XE and IOS XR and includes model-driven telemetry with gRPC for IOS XR. Keep notes about which platform, interface, data model, and desired outcome each exercise uses. This prevents an apparently correct technique from being applied without checking its context.
Avoid unverified question collections and recall-based materials as a substitute for learning. They cannot establish an available exam, they do not build implementation judgment, and memorization does not guarantee a passing result. The published objectives, authorized learning environments, and your own reproducible exercises are more defensible sources for skill development.
Historical delivery details and training context
Before its final testing date, Cisco listed SPAUTO as a 90-minute exam available in English and Japanese, with a U.S. price of $300 and Cisco Learning Credits accepted. Those details describe the official listing supplied for this guide; they should not be used to infer that registration remains open.
Cisco’s SPAUI training description stated that the course prepared learners for SPAUTO and awarded 24 Continuing Education credits toward recertification. That establishes the course’s stated relationship to the exam and its credit value in the supplied materials, but it does not confirm current course availability, a current course schedule, or eligibility for any present certification requirement.
If you are reviewing a past training record, preserve the course completion evidence and check present Cisco policies before relying on it for recertification planning. If you are selecting education now, compare the advertised objectives with the actual skills you need—especially Python workflow, data models, APIs, device programmability, and telemetry—rather than purchasing based only on the old exam association.
Choose the next action based on your goal
Former SPAUTO candidates should verify their credential and recertification position through Cisco, while practitioners should convert the v1.1 blueprint into a skills plan and prospective candidates should research a currently offered Cisco path. Scheduling SPAUTO itself is not a viable next step under the supplied retirement information.
For an engineer maintaining service-provider automation capability, select one foundation topic and one implementation topic for an immediate working exercise. A sensible pairing is Python virtual environments with RESTCONF scripting, or YANG and XPath with NETCONF datastore comparison. Record the inputs, expected outputs, observed outputs, and unresolved questions; that record becomes a useful review artifact.
For a manager or training coordinator, inventory work that touches IOS XE, IOS XR, configuration automation, and model-driven telemetry. Map those responsibilities to the verified blueprint areas, then fund targeted practice where the gap is largest. This produces a more useful development plan than assigning a retired exam’s entire syllabus without regard to job scope.
For anyone seeking a new certification, begin at Cisco’s current exam and certification pages rather than archived SPAUTO material. The historical blueprint can still guide technical preparation, but only a current official listing can establish an active exam, its requirements, and its registration options.
Conclusion
300-535 SPAUTO remains a focused reference for service-provider automation skills, but Cisco’s listed last test date has passed. Treat its v1.1 blueprint as a practical development map: establish Python and structured-data foundations, learn YANG and model-driven interfaces, implement small repeatable workflows, and validate results through state and telemetry. Before committing money or time to certification, confirm the current Cisco path and availability from official sources.
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)
