Cisco DevNet Professional Certification Guide (2026): Exam Details, Cost, Salary & How to Pass

If you’ve heard people rave about “DevNet” and wondered where to start—or how it fits your network automation career today—here’s the good news: Cisco’s DevNet Professional certification has evolved. As of February 3, 2026, the DevNet track was rebranded under the familiar CCNP/CCIE umbrella as CCNP Automation, putting automation where it belongs: at the core of modern networking. Even better, anyone holding an active DevNet Associate, Professional, or Expert was automatically recognized as CCNA, CCNP, or CCIE Automation respectively—no retest required.

In this ultimate guide, you’ll learn exactly how to earn the certification (and what changed), what’s on the new AUTOCOR v2.0 core exam, how to choose the right concentration, how to study efficiently, and how to turn this credential into real career momentum.

Let’s get you automated for success.

What “DevNet Professional” Means in 2026 (CCNP Automation)

Cisco rebranded DevNet to “Automation” to make a simple point: network automation—and increasingly, AI‑assisted automation—isn’t a niche. It’s a must‑have skill set that sits alongside routing, switching, and security in professional‑level networking roles. That’s why DevNet Professional became CCNP Automation, and DevNet Expert became CCIE Automation.

What the certification proves you can do:

• Design, deploy, and operate end‑to‑end network automation systems

• Build and use APIs across Cisco platforms

• Implement Infrastructure as Code (IaC) with Python, Ansible, and Terraform

• Build CI/CD workflows for network changes

• Instrument networks with model‑driven telemetry and observability

• Apply secure coding and operations best practices

• Leverage “AI in automation” for practical, assistive workflows

Actionable takeaway:

• Use the name that matches today’s Cisco catalog—and hiring filters. On your resume and LinkedIn, list “CCNP Automation (formerly DevNet Professional)” to appear in both searches.

How to Earn CCNP Automation (Formerly DevNet Professional)

Earning the certification still follows the trusted two‑exam model: one core exam plus one concentration.

• Core exam (required):

  • 350‑901 AUTOCOR — Designing, Deploying and Managing Network Automation Systems

  • 120 minutes, English/Japanese, price $400

  • Tests end‑to‑end automation systems design, IaC, operations, and AI‑assisted automation

• Choose one concentration (90 minutes, English/Japanese, price $300):

  • 300‑435 ENAUTO — Automating and Programming Cisco Enterprise Solutions (also counts toward CCNP Enterprise)

  • 300‑635 DCNAUTO — Automating Cisco Data Center Networking Solutions (also counts toward CCNP Data Center)

Other key logistics:

• Results are pass/fail and typically post within 48 hours (see the CCNP Automation exams page for details)

• Concentration lineup changes: older DevNet‑era concentrations (300‑910 DEVOPS, 300‑735 SAUTO, 300‑535 SPAUTO, 300‑920 DEVWBX) retired by Feb 2, 2026 (or earlier). Today’s CCNP Automation path uses ENAUTO or DCNAUTO.

Actionable takeaway:

• Budget $700 for exam fees (core $400 + concentration $300). Double‑check your company’s certification reimbursement policy before you pay out of pocket.

Who Should Pursue It (And What You Should Know First)

There are no formal prerequisites for CCNP Automation. That said, you’ll ramp fastest if you have:

• Solid Python and Git basics

• Comfort with JSON/YAML, REST APIs, and auth flows

• Familiarity with Ansible and an IaC mindset (Terraform experience helps)

• Working knowledge of enterprise networking (for ENAUTO) or data center (for DCNAUTO)

• Some hands‑on time with Cisco platforms (Catalyst Center, SD‑WAN, Meraki; or ACI/NX‑OS)

Actionable takeaway:

• If you’re fresh to Python/APIs, invest 2–3 weeks leveling up (Python fundamentals, requests, JSON/YAML, Git workflows). It pays off across the entire blueprint.

AUTOCOR v2.0 (350‑901): What’s New and What to Master

AUTOCOR v2.0 is the heartbeat of CCNP Automation. Compared to the legacy DEVCOR blueprint, it emphasizes automation systems design, IaC, and operations—with explicit “AI in automation” outcomes.

Core topic themes to prepare:

1. Designing automation systems

• Architecture patterns for controllers, agents, and pipelines

• Reliability, scalability, idempotency, modular design

• Secrets, credential stores, and zero‑trust principles

Actionable insight: Diagram before you code. Sketch the control plane, data flows, and failure domains. Then map each to telemetry and alerting.

2. Infrastructure as Code (IaC)

• Python patterns for network tasks

• Ansible roles/playbooks; Jinja templating; vaults

• Terraform for network resources; state/backends; plan/apply/destroy

Actionable insight: Treat your network config as product code. Enforce code review and automated lint/tests on every PR—no exceptions.

3. CI/CD for networks

• Pipelines (GitHub Actions, Jenkins, GitLab CI) for validate → test → deploy → rollback

• Artifact/version management; canary and feature‑flag style network changes

• Integrations with testbeds and simulation (e.g., Cisco Modeling Labs)

Actionable insight: Start with a simple validate → dry‑run pipeline. Add rollback automation in a second iteration.

4. Observability and model‑driven telemetry

• gNMI, NETCONF/RESTCONF, YANG models

• Streaming telemetry to time‑series/log stores and SLO‑based alerting

• Health dashboards for services and network intents

Actionable insight: Define 3–5 service‑level objectives (SLOs) for your lab (e.g., loss/latency thresholds, route convergence). Build alerts your team will actually act on.

5. Secure coding and operations

• Secure API consumption (TLS, certs, token lifecycles)

• Dependency and SBOM awareness; least privilege

• Change governance, approvals, and audit trails

Actionable insight: Store secrets in a dedicated manager (e.g., HashiCorp Vault/Azure Key Vault) and rotate regularly—don’t leave tokens in repo CI variables forever.

6. AI in automation (assistive, guardrailed)

• LLM‑assisted workflows for config generation, diff explanation, or playbook drafts

• Guardrails: schema validation, intent checking, pre‑deployment “safety checks”

• Responsible automation: human‑in‑the‑loop and rollback readiness

Actionable insight: Make “LLM‑drafted” changes pass the same validators as human‑written ones—lint, schema, policy, and dry‑run—before they even hit a review.

Where to practice AUTOCOR topics:

• Cisco U. AUTOCOR course (v2.0) includes practical projects like LLM‑powered network agents and MCP servers.

Concentration Choices: ENAUTO vs. DCNAUTO

ENAUTO (300‑435): Enterprise Automation

What you’ll work with:

• Platforms: IOS XE (device‑centric), Catalyst Center (intent‑based), SD‑WAN, Meraki

• Tooling: Python, Ansible, NETCONF/RESTCONF, YANG, Git, JSON/YAML

• Use cases: zero‑touch provisioning, intent‑policy automation, bulk changes, telemetry‑driven ops

Why pick ENAUTO:

• You operate campus/WAN networks and want to automate Catalyst/SD‑WAN/Meraki workflows

• You want the option to stack CCNP Enterprise later; ENAUTO counts toward both CCNP Enterprise (as a concentration) and CCNP Automation

Actionable takeaway:

• Build a “Day‑0 to Day‑N” lab for a small campus: ZTP with Catalyst Center APIs → template push via Ansible → telemetry alerts to your dashboard.

DCNAUTO (300‑635): Data Center Automation

What you’ll work with:

• Platforms: ACI, NX‑OS, data center fabric automation

• Tooling: Terraform/Ansible, Python, controller APIs, telemetry

• Use cases: intent‑based fabric deployment, tenant segmentation, continuous compliance, capacity/SLO tracking

Why pick DCNAUTO:

• Your environment relies on ACI/NX‑OS and you want to enforce IaC with testable, repeatable pipelines

• You might also pursue CCNP Data Center; DCNAUTO counts toward that path, too

Actionable takeaway:

• Script a “golden‑config drift” detector for a lab ACI tenant. If drift is detected, open a pull request with the compliant state.

Note on older concentrations:

• Some DevNet‑era exams (e.g., SAUTO, SPAUTO, DEVOPS, DEVWBX) were retired by Feb 2, 2026 (or earlier)—don’t plan on them for CCNP Automation today.

Your 90‑Day Study Plan (Battle‑Tested and Flexible)

Week 0–1: Map the terrain

• Choose your concentration (ENAUTO vs. DCNAUTO).

• Download the AUTOCOR v2.0 topics PDF and your concentration outline. Translate each topic into a hands‑on task in your lab backlog.

Weeks 2–6: Core (AUTOCOR) execution

• Learning: Work through Cisco U.’s AUTOCOR path. Take pre/post assessments to focus your time.

• Labs:

  • Python + Ansible: build reusable roles for VLANs, OSPF, QoS; use vaults for secrets.

  • Terraform: manage a subset of network objects; practice plan/apply/destroy with state in a remote backend.

  • CI/CD: add lint/schema checks; validate diffs; implement a dry‑run; write a rollback job.

  • Telemetry: stream key metrics to a time‑series DB; alert on SLO breaches.

  • Security: never hardcode tokens; implement token rotation; prove audit trails.

• Tools: Use DevNet Sandbox (free) and Cisco Modeling Labs (personal subscription via Cisco U.) for repeatable topologies.

Weeks 7–10: Concentration specialization

• ENAUTO: Automate across IOS XE, Catalyst Center, SD‑WAN, and Meraki; build a “bulk change” pipeline linked to a change request template.

• DCNAUTO: Provision an ACI tenant via Terraform; enforce policy with validation tests; dashboard key tenant SLOs.

• Continue tying every hands‑on task to a specific blueprint line.

Weeks 11–12: Exam readiness

• Do blueprint‑style mocks (closed‑book). Score, then remediate weak areas with labs or docs.

• Schedule the concentration first if it’s newer to you; then take AUTOCOR while momentum is high (1–2 weeks after).

• Night‑before checklist: sleep, hydration, print your Pearson VUE confirmation, and know the retake timing if needed (5‑day wait for failed pro‑level exams.

Actionable takeaway:

• Track every lab as a small Git repo with READMEs and runbooks. You’ll reuse them in interviews and on the job.

Must‑Use Resources (That Stay Current)

• Cisco U. Learning Paths (AUTOCOR, ENAUTO, DCNAUTO): curated content matched to current blueprints.

• DevNet Sandbox: free, reservable labs and APIs.

• Cisco Modeling Labs (CML): personal subscription via Cisco U. for virtual topologies.

• Exam topics PDFs: always align study to the active blueprint (e.g., AUTOCOR v2.0).

A quick caution on books:

• Older “DEVCOR” Official Cert Guides can help with fundamentals, but AUTOCOR v2.0 adds new emphasis (e.g., AI‑assisted workflows). Use the blueprint and Cisco U. as your source of truth for what’s actually tested now.

Costs, Recertification, and Maximizing ROI

• Exam fees: $400 (core) + $300 (concentration) = $700 total. Check company reimbursement before paying out of pocket.

• Certification validity: 3 years for most Cisco certs (including professional‑level).

• Recertification (CE credits):

  • Professional level requires 80 CE credits within 3 years.

  • CE from passing exams is automatic: concentration = 40 CE; core = 80 CE (credits auto‑applied).

  • Strategy: One more concentration (40 CE) + targeted Cisco U. CE courses can easily renew you; or simply pass a technology core again (80 CE).

• Salary context (US snapshot):

  • Network Automation Engineer roles regularly land in low‑ to mid‑six‑figure ranges; check current trackers like ZipRecruiter and Salary.com for your market when negotiating.

• Double‑value exam: ENAUTO counts toward both CCNP Enterprise and CCNP Automation, which can boost ROI if you plan to stack credentials over time.

Actionable takeaway:

• Map a 3‑year CE plan the week you pass—don’t wait until year 3. Pick two Cisco U. learning paths with CE and one additional concentration or core re‑sit.

Real‑World Project Ideas (Show, Don’t Tell)

1. Enterprise “Day‑0 to Day‑N” Automation

• Goal: Provision a new branch (Day‑0) and maintain it safely (Day‑N).

• Tools: Catalyst Center API, Ansible, GitHub Actions, Meraki API, RESTCONF.

• Steps:

  • Build a device‑onboarding playbook (templates + variables).

  • Implement a CI pipeline: lint → validate (schema) → dry‑run → deploy (with approvals).

  • Add automatic PRs for config drift; tag reviewers based on service ownership.

  • Use telemetry to trigger rollback if SLOs breach.

• What it proves: End‑to‑end intent execution with guardrails and evidence.

2. Data Center Tenant Automation with Drift Control

• Goal: Create and manage an ACI tenant declaratively.

• Tools: Terraform (ACI provider), Ansible (post‑config), Prometheus/Grafana for observability.

• Steps:

  • Author Terraform modules for VNIDs/contracts/EPGs; remote state backend.

  • Write validation tests for tenant policy; runners execute on every PR.

  • Build rollback job (revert to last good plan) on SLO breach.

  • Alert if diffs diverge from repo (unauthorized changes).

• What it proves: IaC basics, testable changes, and continuous compliance.

3. AI‑Assisted Change Planning

• Goal: Draft, validate, and document change plans with a safe LLM‑assisted workflow.

• Tools: LLM prompt templates, schema validators, Ansible/Terraform, Secrets Manager.

• Steps:

  • Use an LLM to produce a proposed change (with constraints), but block until it passes schema/intent checks.

  • Require human approval; then deploy with CI pipeline.

  • Auto‑generate post‑change report from telemetry.

• What it proves: Responsible AI assistance, not “auto‑pilot” networking.

Actionable takeaway:

• Package each project with a top‑level README, a runbook (how to reproduce), and a short demo video. These become powerful interview artifacts.

Common Pitfalls (And How to Avoid Them)

• Studying outdated material

  • Fix: Always align to the current AUTOCOR v2.0 and concentration blueprints. Use Cisco U. courses mapped to the latest versions.

• Not doing enough hands‑on

  • Fix: Reserve DevNet Sandbox labs and run recurring CML topologies to build muscle memory.

• Skipping security and operations

  • Fix: Add secrets rotation, audit trails, approval workflows, and rollback tests to every pipeline you build.

• Ignoring AI‑assisted scenarios

  • Fix: Implement at least one safe LLM‑assisted draft + validate pattern so you’re comfortable with the new emphasis in AUTOCOR v2.0.

FAQs

Q1: Is DevNet Professional still available?
A1: The certification was renamed to CCNP Automation on Feb 3, 2026. If you held an active DevNet Professional, you were automatically recognized as CCNP Automation—no retesting required.

Q2: Which concentration exams count toward CCNP Automation today?
A2: 300‑435 ENAUTO (Enterprise) and 300‑635 DCNAUTO (Data Center). Several older DevNet‑era concentrations (e.g., DEVOPS, SAUTO, SPAUTO, DEVWBX) were retired by Feb 2, 2026 (or earlier).

Q3: How long is CCNP Automation valid, and how do I renew?
A3: It’s valid for 3 years. You can recertify with 80 Continuing Education (CE) credits (or a combination of CE + exam). Passing a concentration earns 40 CE; passing a technology core earns 80 CE.

Q4: Does ENAUTO help with other CCNPs?
A4: Yes. ENAUTO is also a valid concentration for CCNP Enterprise, which can boost your ROI if you plan to stack credentials.

Q5: How much does it cost to earn CCNP Automation?
A5: Plan on $700 in exam fees: $400 for the core (AUTOCOR) and $300 for one concentration (ENAUTO or DCNAUTO).

Conclusion:
The path once known as DevNet Professional is now front and center as CCNP Automation—without losing what made DevNet special. You’ll still learn APIs, Python/Ansible/Terraform, and IaC—but now with a sharpened focus on automation systems design, secure operations, observability, and AI‑assisted workflows that reflect how real teams ship changes. If you want to stand out as the engineer who can translate business intent into reliable, testable, and auditable network changes, this is the credential to chase.

Your next step is simple:

1. Pick ENAUTO or DCNAUTO,

2. Download the AUTOCOR v2.0 blueprint, and

3. Start building hands‑on projects that map directly to exam objectives.