The transition from Cisco DevNet Professional to CCNP Automation is not a simple substitution of words on a certificate. On February 3, 2026, Cisco introduced the CCNA, CCNP and CCIE Automation naming framework; the professional core changed from 350-901 DEVCOR to 350-901 AUTOCOR. Candidates who last studied the DevNet Professional pathway need to distinguish a renamed certification, a changed core examination, and knowledge that still transfers. This distinction determines what to keep, what to relearn and which examination can actually be scheduled.
What changed on February 3, 2026
The old 350-901 DEVCOR core reached its final testing date on February 2, 2026. From February 3 onward, candidates preparing for the professional automation core should use the current Cisco 350-901 AUTOCOR objectives. Although DEVCOR and AUTOCOR share the 350-901 number, they are not interchangeable editions of the same blueprint. The current exam is Designing, Deploying, and Managing Network Automation Systems, rather than the retired Developing Applications Using Cisco Core Platforms and APIs.
The associate and expert naming changes should not be confused with the professional core replacement. Cisco’s associate automation examination retains the 200-901 number under CCNA Automation; the Cisco CCNA Automation 200-901 path is a separate associate credential, not a substitute for a professional core or concentration. Cisco has also stated that holders of active DevNet certifications were recognized under the renamed certification framework. That recognition is different from claiming a retired exam remains available for new attempts.
A current CCNP Automation candidate completes the AUTOCOR core plus one eligible concentration examination. Cisco currently lists 300-435 ENAUTO, for enterprise automation, and 300-635 DCNAUTO, for data-center automation. The Cisco 300-435 ENAUTO exam addresses enterprise device- and controller-based solutions; the DCNAUTO option emphasizes data-center networking platforms and operations. Candidates should select a concentration based on the environment they intend to operate, not a historical DevNet acronym printed on an old study guide.
What the new professional core actually evaluates
AUTOCOR concentrates on engineering automation as an operational system. Designing a tool for a single API request is useful but insufficient if the tool cannot authenticate safely, locate the correct source of truth, validate inputs, handle failure or demonstrate that the intended state was reached. Real automation systems coordinate inventory, application logic, network controllers, device APIs, configuration repositories, deployment policy and observable outcomes. The exam’s increased attention to infrastructure as code, operations and AI in automation reflects that broader responsibility.
Consider a configuration workflow deployed to a hundred routers. A local script that exits successfully after sending requests has not established that every router accepted the desired configuration. Some devices may be unreachable; others may accept a change that conflicts with the policy of a central controller. Operators need to know exactly what was attempted, what was committed, what is still pending, and which validation results prove service behavior. A scalable design also specifies when the workflow should stop and who may authorize a retry.
Good automation distinguishes desired state, recorded state and observed state. Desired state is the approved policy or deployment request. Recorded state is what the workflow believes it has applied. Observed state comes from device and service readback. Disagreement between those layers is a reconciliation problem; it should not be concealed by a successful task counter. Idempotent operations, rollback points and explicit failure boundaries reduce that uncertainty, but each has limits that the engineer must understand.
Which DEVCOR skills are still useful
DEVCOR-era study of Python, Git, REST APIs, Ansible, Terraform and Cisco platforms continues to have practical value. The value changes when these tools are placed into an end-to-end operational design. Python remains useful for validating structured input and orchestrating requests; Git still tracks changes and reviews; infrastructure as code expresses intended resources or policy; API clients still need authentication, pagination, error handling and rate-limit awareness. What no longer works is treating isolated code exercises as proof that a production automation system is safe.
For example, a learner familiar with REST operations should now evaluate what happens when a controller returns an asynchronous job identifier. An accepted request may mean the controller queued work, not that a remote device is ready. The workflow should poll or subscribe to the authoritative outcome, handle timeouts and record why it stopped. A learner familiar with configuration management should compare intended diffs, approvals and live-state verification, not merely demonstrate that a playbook executed without syntax errors.
A useful migration exercise is to take one old lab and write down its assumptions: which device owns the configuration, where credentials are stored, what a successful response proves, and how a failed partial run is repaired. Then redesign it for a managed fleet. This preserves earlier investment while exposing the additional design and operational topics that the current professional track expects.
Where enterprise and data-center automation diverge
The core examination asks whether a candidate can design reliable automation systems across environments. A concentration tests deeper implementation choices for its area. Enterprise solutions frequently involve IOS XE devices, campus controllers, WAN policy and cloud-managed networks. In this context, engineers should understand where a device API ends and the authoritative controller begins. Our discussion of controller-based automation develops this distinction for Catalyst Center, SD-WAN Manager and Meraki without pretending the platforms expose identical controls.
Structured interfaces matter as well. NETCONF and RESTCONF expose YANG-modeled configuration and operational data, but their transport and datastore semantics differ. Comparing NETCONF and RESTCONF on IOS XE helps clarify when a workflow should perform a controlled configuration operation rather than scrape human-oriented command output. The appropriate API depends on the supported platform, required transaction behavior and the state the workflow can actually verify.
In data centers, automation often coordinates fabric policies, compute/network dependencies and changes that can affect many tenants at once. A task that modifies an attachment or segment must consider the underlying connectivity, policy impact and rollback scope. The relevant concentration should therefore follow the role: operating enterprise endpoints and controllers is different from administering data-center fabric automation. The concentration choice is an engineering decision, not an interchangeable add-on.
Treat security, observability and AI as design requirements
Security is not complete when an API token is stored in a secret vault. The workflow should ask for the smallest permissions necessary, validate the intended device and scope, avoid writing credentials to logs, distinguish human approval from an automated action, and provide an auditable record of changes. Input must be treated as potentially wrong even if it came from a trusted ticketing system. Secrets should be rotated and revocation should not leave an untracked orphaned automation job.
Operational visibility needs more than task output. The service should record an immutable change identifier, intended target set, policy version, start and completion state, platform errors and post-change measurements. Streaming telemetry and webhooks can provide different kinds of evidence: state observations and event notifications. Neither proves that a business requirement is met until the relevant end-to-end check has been defined.
AI-assisted tooling can accelerate analysis or help propose remediation, but a suggestion from an agent is not an approved change. An AI client may select an incorrect tool or misunderstand the permitted scope. The design should expose narrowly scoped capabilities, validate tool arguments, log authorizations and require review for consequential changes. In enterprise automation, controlled AI tool interfaces illustrate why an agent-facing API must not become an unrestricted administrative back door.
A practical decision process for candidates moving from DEVCOR
Start by checking your credential and examination status separately. An active existing certification may have been recognized under the new name, but that does not make its former core bookable. If you are preparing for a new professional certification, confirm the current AUTOCOR blueprint and choose the relevant concentration. If you are still at associate level, decide whether CCNA Automation or a broader networking foundation fits your present responsibilities before buying professional training.
Next, organize existing material by outcome rather than vendor marketing labels. Keep working API, Python, Git and infrastructure-as-code exercises that demonstrate real skills. Mark old DEVCOR sections that have no obvious counterpart as historical background. Add labs that test inventory consistency, secure permissions, policy validation, partial failure, drift and operational telemetry. Use Cisco’s official exam and certification listings to verify current versions, supported languages and registration details; a third-party commercial exam page does not establish official booking availability.
For a realistic capstone, design a safe change that touches multiple devices in a lab. State the expected network behavior and authorization boundaries. Preview changes and record the intended targets. Simulate a timeout and a policy rejection, then show which devices were left unchanged and which need reconciliation. Verify both configuration and traffic behavior afterward. If the process fails, produce evidence that another engineer could use to restore service without guessing what the script last attempted.
The central lesson of the DEVCOR-to-AUTOCOR transition is that modern automation expertise is measured by the reliability of the system around the scripts. Preserve relevant development skills, but prepare to defend architecture, security, observable outcomes and recovery decisions using the current Cisco objectives. That is a more durable professional skill than memorizing the labels of the retired examination.