DevNet Professional Has Moved to CCNP Automation

Cisco DevNet Professional has transitioned into the current CCNP Automation certification. Unlike the associate-level rebrand, the professional track changed more substantially in 2026: the core is now 350-901 AUTOCOR, and candidates pair it with an active automation concentration such as 300-435 ENAUTO or 300-635 DCNAUTO.

The old DevNet Professional page still has value because the role continuity is obvious. Cisco still expects professional candidates to combine software engineering, APIs, application deployment, infrastructure as code, automation operations, and platform-specific implementation. The current track simply brings those skills into Cisco’s broader CCNP naming structure and updates the exam design for modern automation work.

Within the larger Cisco certifications portfolio, CCNP Automation is for engineers who design and operate automation systems, not just people who write occasional scripts.

Professional automation is a systems-design discipline

At associate level, a candidate may automate a task. At professional level, the important question becomes whether the automation system is reliable, secure, observable, maintainable, and safe to use across production infrastructure. That shift changes how candidates should study.

A script that configures ten devices is useful. A professional automation platform must also consider inventory, credentials, concurrency, failure handling, state, approvals, rollback, testing, auditability, and how operators know whether the workflow succeeded. The code is only one part of the system.

The current 350-901 automation scenarios are therefore best studied as architecture problems. Candidates should ask how components interact and what happens when one dependency fails.

Software design matters because automation becomes shared infrastructure

Professional candidates should understand modularity, interfaces, data models, testing, exception handling, packaging, and the tradeoffs between synchronous and asynchronous workflows. They do not need to become application architects, but they need enough software discipline to prevent automation from turning into an unmaintainable collection of scripts.

Reusable functions and modules make behavior easier to test. Clear data models reduce accidental coupling. Logging makes failures diagnosable. Tests reduce the risk of changing a shared library. Documentation and versioning help several engineers work on the same automation platform without guessing at intent.

This is the point where software engineering and network engineering stop being separate conversations. The automation platform is part of production operations and deserves production-grade design.

APIs and event-driven integrations require more than request syntax

Professional automation may integrate controllers, network devices, ticketing systems, inventory platforms, cloud services, observability tools, and security systems. Candidates need to understand not only REST requests but also authentication models, webhooks, asynchronous workflows, pagination, throttling, retries, and how to design around partial failure.

An API that returns HTTP 200 is not proof that the business outcome is correct. Automation should validate state after change, detect drift, and know what to do if only part of a multi-step workflow succeeds.

This is where idempotence becomes especially important. A workflow should be safe to retry when possible. If repeated execution creates duplicate objects or inconsistent policy, the system becomes difficult to recover during an outage.

Infrastructure as code changes how teams manage intended state

Infrastructure as code is one of the clearest differences between ad hoc automation and mature automation operations. Instead of relying on manual configuration as the source of truth, teams describe desired state in version-controlled definitions and use tools to create or reconcile infrastructure.

The concepts in infrastructure as code help candidates reason about declarative models, state, modules, drift, and change control. The important question is not which tool has the most commands; it is how the workflow makes infrastructure changes predictable and reviewable.

Professional candidates should be able to explain how state is protected, how sensitive values are handled, how environments are separated, and how a failed deployment is recovered without losing track of intended configuration.

CI/CD applies software delivery discipline to automation changes

Automation code can affect hundreds or thousands of infrastructure objects, which makes uncontrolled deployment dangerous. CI/CD practices provide a way to test code, validate templates, scan dependencies, build artifacts, and promote changes through environments before production execution.

Understanding CI/CD delivery stages helps candidates think about automated quality gates. Syntax tests are useful, but they are only the beginning. Teams may also validate schemas, run unit tests, check policy, simulate changes, test against a lab, and require approval before production.

Rollback should be designed rather than improvised. Some changes can be reverted automatically; others need a compensating action. Professional automation engineers should know the difference before a pipeline reaches production.

Observability is essential because automation can fail quietly

An automation platform needs metrics, logs, traces, job status, and alerting that tell operators what happened. A workflow that silently skips devices can be more dangerous than one that fails loudly because the organization may believe a policy is enforced when it is not.

Candidates should think about success criteria at several levels: did the job execute, did the API accept the request, did the target reach the intended state, and did the service outcome improve? These are different questions.

Operational dashboards should make failures actionable. An error message that says “job failed” is weak; a useful event identifies the target, stage, cause, retry status, and next action.

Concentrations shape the implementation context

The current CCNP Automation structure uses the AUTOCOR core plus an active concentration. ENAUTO focuses on enterprise automation, including controller-based and device-level workflows, while DCNAUTO focuses on data center networking automation. The core establishes common automation-system skills; the concentration proves depth in a particular operating environment.

The ENAUTO automation scope is especially useful for engineers working with enterprise controllers, network APIs, and programmatic operations. Data center candidates should make similar connections between automation concepts and fabric, controller, and compute/network integration.

Choosing a concentration should reflect the systems a candidate actually operates. A professional credential is most valuable when the automation patterns can be applied at work rather than memorized solely for the exam.

The DevNet transition should change study materials, not erase prior learning

Engineers who earned or studied for DevNet Associate or the current 200-901 CCNAAUTO exam already have useful foundations in APIs, Python, Git, deployment, and infrastructure automation. Those skills carry directly into the current Automation track.

What should change is the reference point. Candidates need current AUTOCOR objectives and current concentration options rather than retired DevNet Professional combinations. Cisco retired several older concentration exams in February 2026 as the track was redesigned.

The current Cisco Automation certifications gives a better picture of how associate, professional, and expert automation credentials now relate.

Current AUTOCOR also reflects the growing role of AI-assisted automation. Professional engineers should understand where AI can help with classification, code generation, anomaly detection, or operational assistance while still preserving deterministic controls around production changes. Generated code and recommendations require validation just like human-written automation; speed does not remove accountability.

Change safety becomes more important as automation scale increases. Mature workflows use dry runs, pre-checks, policy validation, canary targets, staged rollout, health checks, and clear abort conditions. A professional candidate should be able to design a deployment that limits blast radius instead of assuming every target will behave identically.

Secrets management is another production concern. API tokens, service credentials, certificates, and private keys should be stored outside source code, rotated, scoped to the minimum permissions required, and audited. An automation platform with broad credentials can become a high-value attack path, so securing the orchestration system itself is part of the engineering job.

API security should be designed into the platform rather than added after deployment. Professional engineers need to think about authentication, authorization, input validation, rate limits, audit logging, and how exposed endpoints are monitored. The principles of API security matter because automation systems often hold powerful credentials and can change infrastructure at scale.

Teams should also separate control-plane permissions by function. A monitoring workflow rarely needs the same privileges as a configuration deployment pipeline. Service accounts should be scoped deliberately, and high-impact actions may require approval or additional verification. These controls protect the automation system from both attacker abuse and accidental misuse by legitimate operators.

Architecture decisions should also account for ownership. A central automation service may be maintained by a platform team while domain engineers own network intent. Professional designs need clear boundaries around who can change shared libraries, approve production execution, update credentials, and respond to failures. Governance is not bureaucracy when the same automation platform can modify thousands of devices; it is part of keeping large-scale change accountable.

Professional engineers should also think about platform portability. Some automation is intentionally vendor-specific because it uses rich controller features, while other logic benefits from reusable abstractions and common data models. The design choice should be deliberate. Excessive abstraction can hide useful platform capabilities, while excessive coupling can make future migration or multi-domain automation unnecessarily difficult.

Preparation should culminate in a production-style automation project

A strong final project is more useful than another round of disconnected scripts. Define an intended-state change across a set of devices or controllers. Store inventory and code in source control. Validate inputs. Retrieve current state. Generate or apply the change. Handle failures. Verify results. Log every stage. Add tests and a rollback or recovery plan.

Then run the workflow under imperfect conditions: an unreachable target, expired credential, malformed response, partial change, rate limit, or unexpected data. Professional competence is revealed by how the system behaves when everything does not go as planned.

That is the best way to interpret the old DevNet Professional page today. The name is historical, but the destination is current: CCNP Automation expects engineers who can design automation as dependable operational infrastructure rather than as a collection of one-off scripts.

Study with ExamSnap to prepare for Cisco DevNet Professional Practice Test Questions and Answers, Study Guide, and a comprehensive Video Training Course. Powered by the popular VCE format, Cisco DevNet Professional Certification Exam Dumps compiled by the industry experts to make sure that you get verified answers. Our Product team ensures that our exams provide Cisco DevNet Professional Practice Test Questions & Exam Dumps that are up-to-date.