Leanpub Header

Skip to main content
Go to Leanpub.com

Prepare for AUTOCOR 350-901 v2.0: Complete exam course

Designing, Deploying and Managing Network Automation Systems — Complete Exam Prep for CCNP and CCIE Automation

The instructor has published 100% of this course.Last updated on 2026-10-04
Jozef Baros

Pass AUTOCOR 350-901 v2.0 by learning to read and complete real automation code: Ansible, Terraform, RESTCONF, Python, CI/CD, pyATS, MCP and AI agents. 31 lessons, 31 quizzes, 30 exercises and a full mock exam.

Minimum price

$25.00

$35.00

You pay

Author earns

$

Also available for 1 course credit with a Learner Membership

PDF
EPUB
WEB
About

About

About the Course

AUTOCOR 350-901 v2.0 is the core exam for both CCNP Automation and CCIE Automation. It does not ask you to write automation from a blank page. It shows you code someone else wrote — a playbook, a Terraform file, a RESTCONF request, a pipeline, an MCP server, an AI agent — and asks you to complete it, fix it, or explain what it will do. One token decides each answer: merged or present, PUT or PATCH, cache: or artifacts:, json.loads or a plain dictionary.

This course trains exactly that skill. Every lesson teaches the topic from the ground up and then drills it in exam shape. You read real, tested code, complete it, and learn to spot the distractor patterns the exam uses.

What you get

  • 31 lessons that cover every item of the v2.0 blueprint, in blueprint order
  • 31 graded quizzes of exam-style items, each followed by an answer key that explains why the right answer is right and why the strongest distractor is wrong
  • 30 hands-on exercises with fill-in-the-blank code, log diagnosis and design decoding, each with worked solutions
  • A full 40-item mock exam weighted 30/30/20/20 like the real exam, plus a scoring table and a final revision plan
  • Dozens of diagrams that show how pipelines, telemetry, PKI, MCP and agent loops fit together
  • Exam Trap boxes in every lesson that list the fabricated tokens, wrong state words, wrong HTTP verbs and other traps the exam uses
  • The SPADE method and the Ten Laws of answer selection, a repeatable routine for every item, plus a brain-dump sheet to write before question one

What the course covers

Module 0 — Orientation. The exam format, the four domains, the question types and the SPADE answer loop.

Module 1 — Network Automation (30 %).
- Ansible inventories, variables, connection types, resource modules and state words
- Terraform providers, resources, state, loops and modules with the CiscoDevNet/iosxe provider
- RESTCONF and YANG
- Python with Netmiko, ncclient and NAPALM
- How to choose the right automation approach
- Consuming REST APIs at scale: pagination, rate limits and OAuth 2.0

Module 2 — Infrastructure as Code (30 %).
- Git operations
- Building GitLab CI/CD pipelines and diagnosing their failures
- Network simulation with Cisco Modeling Labs
- Reading Docker Compose files
- NetBox as a source of truth
- Building RFC 7951 JSON and YAML from a YANG model

Module 3 — Operations (20 %).
- Model-driven telemetry and the TIG stack
- Logging to syslog and webhooks
- Diagnosing failures from logs and output
- Change validation with pyATS learn and diff
- Getting and deploying CA-signed TLS certificates
- Secure coding: input validation, least privilege and secret management

Module 4 — AI in Automation (20 %).
- Benefits and risks of AI-assisted coding
- Prompt injection and excessive agency, decoded with a four-slot method
- Building an MCP server with Python FastMCP
- Conversational agents with OpenAI and Ollama, from tool calling to a full, guarded agent loop
- Evaluating the accuracy of AI recommendations

Module 5 — Exam Readiness.
- Three end-to-end integrated projects and a lablet routine
- The complete answer-selection method
- A compressed final review and the full mock exam

Who this course is for

  • Network engineers at CCNA or CCNP level who are preparing for AUTOCOR 350-901 v2.0
  • Engineers who already know some Python and YAML and want to move into network automation
  • Engineers who want one structured path from Ansible and Terraform through CI/CD and pyATS to MCP servers and AI agents


What you need:

  • Solid networking fundamentals: VLANs, routing, OSPF and interface configuration on Cisco IOS XE
  • Basic Python and YAML reading skills
  • Optional but recommended: a lab, for example Cisco Modeling Labs or a DevNet sandbox, plus a Linux or WSL workstation with Python, Ansible and Terraform. Lesson 1 shows how to set it up.

This course is independent study material. It is not affiliated with, endorsed by or sponsored by Cisco Systems, Inc. Cisco, CCNP, CCIE and related marks are trademarks of Cisco Systems, Inc.

Share this course

Categories

Networking

Instructor

About the Instructor

Jozef Baros

Jozef Baros is a Senior Network Architect, Teamleader, cybersecurity and technology automation specialist with over a decade of hands-on experience designing, securing, building, and operating large-scale enterprise networks for one of Europe's leading telecommunications providers. Working daily with Cisco and AI infrastructure across global enterprise environments, Jozef brings a rare combination of deep technical expertise and a practical, results-driven approach to complex technology challenges. His professional work spans network architecture, infrastructure automation, cybersecurity and cross-functional project management — giving him a uniquely grounded perspective on how technology actually performs under real-world conditions, not just in theory. He is 4x CCNP Certfied (CCNP Automation, Enterprise, Security and DataCenter), ITIL Foundation certified, Azure Network Engineer certified and Fortinet NSE4.

Material

Course Material

  • Lesson 01 — Course Orientation: The AUTOCOR 350-901 v2.0 Exam

  • Why this matters on the exam

  • The exam at a glance

  • The four domains

  • Question types: you are reading code, not writing it

  • Why Domains 1.0 and 2.0 need precision

  • Why Domain 4.0 needs a decoding strategy

  • Three mindsets for the chair: P-A-C

  • The SPADE loop — a 90-second procedure for every question

  • SPADE on a sample question

  • How this course is built

  • Building your lab

  • 1. Python virtual environment and tools

  • 2. Terraform

  • 3. Devices to automate

  • 4. Smoke test

  • Your study plan

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 01 — Read the blueprint like an examiner

  • Exercise 01 — Solutions

  • Quiz

  • Quiz 01 — Course Orientation

    3 attempts allowed

  • Quiz 01 — Answer key and explanations

  • Lesson 02 — Ansible Foundations: Inventory, Variables and Connection Types

  • Why this matters on the exam

  • The agentless control-node model

  • Inventory: telling Ansible what to manage

  • INI format

  • YAML format — the same inventory

  • Variables: where data lives

  • Any other folder needs vars_files:

  • Variable precedence

  • Secrets with Ansible Vault

  • Connection variables: how Ansible talks to each device

  • network_cli — the default path for IOS XE

  • netconf — YANG-modelled XML

  • httpapi — REST on the device

  • local — for controller and cloud APIs

  • Collections and fully qualified names

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 02 — Inventory for a mixed lab

  • Exercise 02 — Solutions

  • Quiz

  • Quiz 02 — Ansible Foundations

    3 attempts allowed

  • Quiz 02 — Answer key and explanations

  • Lesson 03 — Ansible Configuration Management: Resource Modules, States and Playbooks

  • Why this matters on the exam

  • Four kinds of network module

  • Resource modules for the five blueprint areas

  • VLANs — cisco.ios.ios_vlans

  • Interface settings — three related modules

  • OSPF — process and interface level

  • ACLs — definition and application

  • Asset management — facts, not configuration

  • The state vocabulary

  • Write states — “Most Routers Only Do Pushes”

  • Read states — “Ghosts Read Passively”

  • Choosing a state — the decision order

  • Module generations and other state vocabularies

  • Legacy singular modules

  • Modules with no state: at all

  • Other platforms, other words

  • The ios_acls exception

  • Raw CLI: ios_config and ios_command

  • Playbook techniques for safe network changes

  • Dry runs: --check and --diff

  • register, loop and when

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 03 — Name the module and the state

  • Exercise 03 — Solutions

  • Quiz

  • Quiz 03 — Resource Modules, States and Playbooks

    3 attempts allowed

  • Quiz 03 — Answer key and explanations

  • Lesson 04 — Terraform for Network Automation: Providers, Resources and State

  • Why this matters on the exam

  • What makes Terraform different

  • The workflow

  • Reading plan output

  • Project layout

  • The IOS XE provider

  • Which protocol does the provider use?

  • Resources for the five blueprint areas

  • VLANs

  • Interface settings

  • OSPF

  • ACLs

  • Asset management

  • The four block types: VLDO

  • References: Type.Name.Attribute

  • State, locking and drift

  • What the state file is

  • State locking

  • Drift

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 04 — Complete the IOS XE configuration

  • Exercise 04 — Solutions

  • Quiz

  • Quiz 04 — Terraform Fundamentals

    3 attempts allowed

  • Quiz 04 — Answer key and explanations

  • Lesson 05 — Terraform in Practice: Loops, Modules and Multi-Device Projects

  • Why this matters on the exam

  • From one resource to many

  • count — a number of copies

  • for_each — one instance per key

  • for_each refuses a list

  • Why count churns and for_each does not

  • Transforming collections: for expressions and splats

  • Modules: reusable building blocks

  • Writing the child module

  • Calling the module

  • Module sources

  • One module, many sites: for_each on a module

  • Several devices in one configuration

  • Provider aliases

  • tfvars files per environment

  • Reading terraform plan output

  • Migrating from count to for_each without downtime

  • Project A — VLAN fabric on two access switches

  • Project B — OSPF underlay on a router pair

  • Project C — ACL policy applied to edge ports

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 05 — From count to for_each, and back to the plan

  • Exercise 05 — Solutions

  • Quiz

  • Quiz 05 — Terraform in Practice

    3 attempts allowed

  • Quiz 05 — Answer key and explanations

  • Lesson 06 — RESTCONF (RFC 8040) and YANG Models

  • Why this matters on the exam

  • What RESTCONF is

  • Enabling RESTCONF on IOS XE

  • The URL: four parts, read left to right

  • Headers and authentication

  • YANG: the model behind the URL

  • Reading pyang -f tree output

  • From tree to URL and body

  • The HTTP methods

  • Status codes

  • Query parameters

  • The three model families

  • Worked solutions for the five blueprint areas

  • VLANs — native model

  • Interface settings — IETF model

  • OSPF — native model

  • ACLs — native model

  • Asset management — OpenConfig platform model

  • RESTCONF or NETCONF?

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 06 — From YANG tree to request

  • Exercise 06 — Solutions

  • Quiz

  • Quiz 06 — RESTCONF and YANG

    3 attempts allowed

  • Quiz 06 — Answer key and explanations

  • Lesson 07 — Python Network Automation: Netmiko, ncclient and NAPALM

  • Why this matters on the exam

  • The toolbox: one library per transport

  • Python grammar the exam is written in

  • Classes, objects and methods

  • Type hints: colon in, arrow out

  • Dictionary unpacking: **device

  • try / except / else / finally

  • Context managers: with

  • Netmiko: automating the CLI

  • Interfaces, OSPF and ACLs with send_config_set

  • Asset management: text into data

  • Many devices at once

  • ncclient: NETCONF from Python

  • Reading configuration: get_config

  • Writing configuration: edit_config

  • Transactions: candidate, lock, commit

  • NAPALM: one API for many vendors

  • Merge, replace, compare, commit

  • RESTCONF from Python with requests

  • Reading tracebacks

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 07 — Complete and debug three scripts

  • Exercise 07 — Solutions

  • Quiz

  • Quiz 07 — Python Network Automation

    3 attempts allowed

  • Quiz 07 — Answer key and explanations

  • Lesson 08 — Selecting the Right Automation Approach

  • Why this matters on the exam

  • Two ideas that decide most questions

  • Imperative vs declarative

  • Idempotency

  • The three categories

  • Infrastructure as code frameworks

  • Low-code / no-code

  • Custom applications

  • Decision criteria

  • Technical requirements

  • Business requirements

  • A selection procedure

  • Worked scenarios

  • Source of truth and GitOps

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 08 — Choose and justify

  • Exercise 08 — Solutions

  • Quiz

  • Quiz 08 — Selecting the Automation Approach

    3 attempts allowed

  • Quiz 08 — Answer key and explanations

  • Lesson 09 — Consuming REST APIs at Scale

  • Why this matters on the exam

  • The resilient API client

  • Status codes decide the next action

  • Authentication workflows

  • API key and Basic: one step

  • Catalyst Center: a token from a login call

  • SD-WAN Manager: cookie plus XSRF token

  • OAuth 2.0 client credentials: two steps and an expiry

  • Persistent authentication

  • requests.Session keeps headers, cookies and connections

  • Token caching with proactive and reactive refresh

  • Pagination

  • Offset / limit — Catalyst Center

  • Page number — ISE ERS

  • Cursor / token — a body field

  • Link header — Meraki

  • Rate limiting

  • Honour Retry-After, then back off exponentially with jitter

  • Retries at the transport layer: Retry + HTTPAdapter

  • Structured error handling

  • Timeouts on every call

  • The exception hierarchy

  • Idempotency and retries

  • Putting it together

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 09 — Complete a paginated, rate-limit-aware Meraki client

  • Exercise 09 — Solutions

  • Quiz

  • Quiz 09 — Consuming REST APIs at Scale

    3 attempts allowed

  • Quiz 09 — Answer key and explanations

  • Lesson 10 — Version Control with Git

  • Why this matters on the exam

  • The model: three areas and movable pointers

  • Working directory, index, repository

  • Branches are pointers; HEAD is where you are

  • 2.1.a Merging a branch

  • Fast-forward

  • Three-way merge and the merge commit

  • Squash merge

  • Rebase in one paragraph

  • Resolving a merge conflict

  • 2.1.b git cherry-pick

  • 2.1.c git reset

  • 2.1.d git checkout

  • Detached HEAD

  • 2.1.e git revert

  • Choosing the undo

  • Keeping the repository clean: .gitignore

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 10 — Predict the commit graph

  • Exercise 10 — Solutions

  • Quiz

  • Quiz 10 — Version Control with Git

    3 attempts allowed

  • Quiz 10 — Answer key and explanations

  • Lesson 11 — Building a GitLab CE CI/CD Pipeline for Network Automation

  • Why this matters on the exam

  • How GitLab CI/CD runs your automation

  • The keyword toolkit

  • The four stages for network automation

  • A complete pipeline

  • 2.3.a The build stage

  • 2.3.b The prevalidation stage

  • Test reports

  • 2.3.c The deploy stage

  • rules: and when:

  • 2.3.d The post-validation stage

  • Artifacts versus cache

  • Variables and secrets

  • Two places for variables

  • Runners, tags and placement

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 11 — Complete the four-stage pipeline

  • Exercise 11 — Solutions

  • Quiz

  • Quiz 11 — Building a GitLab CE CI/CD Pipeline

    3 attempts allowed

  • Quiz 11 — Answer key and explanations

  • Lesson 12 — Diagnosing GitLab CI/CD Pipeline Failures

  • Why this matters on the exam

  • How pipelines fail

  • Reading a job log

  • Tracebacks and chained exceptions

  • Exit codes

  • “Prints success, exits 1”

  • The three official failure classes: DVT

  • D — missing dependency

  • V — incompatible versions

  • T — failed test

  • The hidden causes: CUPPA

  • Twelve failure scenarios

  • 1. “It worked yesterday” — the unpinned dependency

  • 2. “File not found” in deploy — cache instead of artifacts

  • 3. The check-mode lie

  • 4. The protected variable that vanishes

  • 5. Timeout to a healthy device — runner placement

  • 6. Prints success, exits 1

  • 7. The pipeline will not even start

  • 8. The stale Terraform state lock

  • 9. Post-validation fails after everything else passed

  • 10. ModuleNotFoundError for a listed package — the stale cache

  • 11. Connection lost in the middle of the play

  • 12. HTTP 409 Conflict from RESTCONF

  • Scenario map

  • A repeatable diagnosis method

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 12 — Diagnose five pipeline logs

  • Exercise 12 — Solutions

  • Quiz

  • Quiz 12 — Diagnosing GitLab CI/CD Pipeline Failures

    3 attempts allowed

  • Quiz 12 — Answer key and explanations

  • Lesson 13 — Network Simulation with Cisco Modeling Labs (CML)

  • Why this matters on the exam

  • What CML is

  • The building blocks

  • Lab and node states

  • Building a test topology from YAML

  • Automating CML with virl2_client

  • Connecting

  • Importing a topology and running the lab

  • Building a lab in code

  • Talking to the nodes

  • Always tear down

  • The CML REST API directly

  • CML in the CI/CD pipeline

  • A known-good baseline

  • Choosing a test environment

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 13 — Complete a CML lab YAML and a virl2_client script

  • Exercise 13 — Solutions

  • Quiz

  • Quiz 13 — Network Simulation with CML

    3 attempts allowed

  • Quiz 13 — Answer key and explanations

  • Lesson 14 — Interpreting a Docker Compose File

  • Why this matters on the exam

  • The shape of a Compose file

  • Project, service, container

  • Services: the per-service keys

  • image or build

  • ports: host first, container second

  • environment and env_file

  • depends_on: start order, not readiness

  • Networks: who can reach whom

  • The default network

  • Custom networks for isolation

  • Network drivers

  • Volumes: what survives

  • Links: the legacy key

  • Predicting stack behaviour

  • Stack 1 — NetBox as a source of truth

  • Stack 2 — a telemetry stack (Telegraf, InfluxDB, Grafana)

  • Stack 3 — an automation runner

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 14 — Interpret a multi-service Compose file

  • Exercise 14 — Solutions

  • Quiz

  • Quiz 14 — Interpreting a Docker Compose File

    3 attempts allowed

  • Quiz 14 — Answer key and explanations

  • Lesson 15 — Integrating a Source of Truth

  • Why this matters on the exam

  • What a source of truth is

  • One authority per kind of data

  • The integration pattern

  • Reading NetBox data

  • The REST API

  • GraphQL: exactly the fields you need

  • pynetbox: the Python client

  • NetBox as a dynamic Ansible inventory

  • Rendering configuration with Jinja2

  • From NetBox records to a rendering context

  • The same thing in Ansible

  • Detecting drift

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 15 — Complete a pynetbox query, a Jinja2 template and an inventory

  • Exercise 15 — Solutions

  • Quiz

  • Quiz 15 — Integrating a Source of Truth

    3 attempts allowed

  • Quiz 15 — Answer key and explanations

  • Lesson 16 — Constructing YAML and JSON from a YANG Data Model

  • Why this matters on the exam

  • Schema versus instance data

  • The four mappings

  • Reading a pyang tree

  • The three rules of RFC 7951 JSON

  • Rule 1 — Prefix at the top and wherever the module changes

  • Rule 2 — Lists are arrays, and every entry carries its key

  • Rule 3 — Types decide the quoting

  • From JSON to YAML

  • Where YAML can change your data

  • Converting with Python

  • Building payloads for the three model families

  • Cisco-IOS-XE-native — the CLI as a tree

  • ietf — the standard models

  • OpenConfig — config and state containers

  • Spotting invalid representations

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 16 — Write JSON and YAML for three YANG trees

  • Exercise 16 — Solutions

  • Quiz

  • Quiz 16 — YANG to JSON and YAML

    3 attempts allowed

  • Quiz 16 — Answer key and explanations

  • Lesson 17 — Model-Driven Telemetry Architecture

  • Why this matters on the exam

  • From polling to streaming

  • The architectural components

  • Sensor paths

  • Encodings

  • Transports

  • Dial-out and dial-in

  • gNMI subscription modes

  • Cadence: periodic or on-change

  • Reading an IOS XE subscription

  • Verifying on the device

  • Dial-in on IOS XE

  • The collector: the TIG stack

  • Telegraf for dial-out

  • Telegraf for dial-in (gNMI)

  • Where telemetry meets the rest of the course

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 17 — Complete a telemetry subscription and identify its components

  • Exercise 17 — Solutions

  • Quiz

  • Quiz 17 — Model-Driven Telemetry

    3 attempts allowed

  • Quiz 17 — Answer key and explanations

  • Lesson 18 — Logging Strategy: Syslog and Webhooks

  • Why this matters on the exam

  • What a logging strategy decides

  • Severity: the syslog scale

  • Python logging in four objects

  • Two level checks

  • Writing log calls well

  • Destination 1 — syslog

  • The devices log to the same place

  • Destination 2 — webhooks

  • A webhook handler for logging

  • Structured logs and correlation IDs

  • What never goes into a log

  • Putting it together: a complete configuration

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 18 — Complete a logging configuration with syslog and webhook handlers

  • Exercise 18 — Solutions

  • Quiz

  • Quiz 18 — Logging Strategy: Syslog and Webhooks

    3 attempts allowed

  • Quiz 18 — Answer key and explanations

  • Lesson 19 — Diagnosing Automation Problems from Logs and Output

  • Why this matters on the exam

  • A repeatable method

  • Reading Python tracebacks

  • Chained exceptions: the first block is the cause

  • Exception signatures

  • Reading Ansible output

  • Common Ansible network messages

  • Reading Terraform errors

  • HTTP status codes in API logs

  • Correlating automation logs with device logs

  • Symptom versus root cause

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 19 — Diagnose six log excerpts

  • Exercise 19 — Solutions

  • Quiz

  • Quiz 19 — Diagnosing Automation Problems from Logs and Output

    3 attempts allowed

  • Quiz 19 — Answer key and explanations

  • Lesson 20 — Change Validation with pyATS CLI Tools

  • Why this matters on the exam

  • The pyATS family

  • The testbed file

  • Validating the testbed

  • pyats parse: one command, structured

  • pyats learn: a whole feature, structured

  • pyats diff: what changed

  • Excluding noise

  • The pre-/post-validation workflow

  • Automating the verdict

  • Test scripts and jobs: pyats run job

  • pyATS in the pipeline

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 20 — Complete a testbed file and interpret a pyats diff result

  • Exercise 20 — Solutions

  • Quiz

  • Quiz 20 — Change Validation with pyATS

    3 attempts allowed

  • Quiz 20 — Answer key and explanations

  • Lesson 21 — Obtaining and Deploying CA-Signed TLS Certificates

  • Why this matters on the exam

  • PKI in one table

  • The chain of trust

  • The process, end to end

  • Generating a key and a CSR with OpenSSL

  • Inspecting and verifying what comes back

  • Deploying on IOS XE: the trustpoint

  • Automatic enrolment and renewal with SCEP

  • Deploying on automation servers

  • Making Python clients verify

  • Diagnosing TLS errors

  • Revocation and lifetime

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 21 — Order the certificate workflow and fix TLS errors

  • Exercise 21 — Solutions

  • Quiz

  • Quiz 21 — CA-Signed TLS Certificates

    3 attempts allowed

  • Quiz 21 — Answer key and explanations

  • Lesson 22 — Secure Coding Practices for Network Automation

  • Why this matters on the exam

  • The attack surface of an automation solution

  • Pillar 1 — Input validation

  • The standard library first

  • Schemas for structured input

  • Pillar 2 — Preventing injection

  • 1. The shell

  • 2. The device CLI

  • 3. Templates

  • 4. Deserialisation

  • Pillar 3 — Authentication and least privilege

  • Pillar 4 — Secret management

  • Environment variables and CI/CD variables

  • Ansible Vault

  • HashiCorp Vault (or a cloud secret manager)

  • Catching leaks before they happen

  • Pillar 5 — Transport and dependencies

  • Putting it together: a hardened function

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 22 — Find and fix five security defects

  • Exercise 22 — Solutions

  • Quiz

  • Quiz 22 — Secure Coding Practices

    3 attempts allowed

  • Quiz 22 — Answer key and explanations

  • Lesson 23 — Benefits and Risks of AI-Assisted Code Development

  • Why this matters on the exam

  • The benefits are real

  • Risk 1 — Data privacy

  • Mitigations

  • Risk 2 — IP ownership and licensing

  • Mitigations

  • Risk 3 — Code validation

  • The validation loop

  • Over-reliance and skills

  • A policy that works

  • Decision table for scenario questions

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 23 — Classify ten scenarios

  • Exercise 23 — Solutions

  • Quiz

  • Quiz 23 — Benefits and Risks of AI-Assisted Code Development

    3 attempts allowed

  • Quiz 23 — Answer key and explanations

  • Lesson 24 — Security Risks in AI-Based Network Automation

  • Why this matters on the exam

  • How an agent changes the threat model

  • The OWASP risks that matter for network automation

  • Direct and indirect prompt injection

  • Mitigations for injection

  • Excessive agency

  • Insecure output handling and sensitive information disclosure

  • The four-slot decoder

  • Worked example

  • Decoding the word “exploit”

  • Trap patterns in Domain 4.0

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 24 — Decode five agent designs with the four-slot method

  • Exercise 24 — Solutions

  • Quiz

  • Quiz 24 — Security Risks in AI-Based Network Automation

    3 attempts allowed

  • Quiz 24 — Answer key and explanations

  • Lesson 25 — Building an MCP Server with Python FastMCP

  • Why this matters on the exam

  • What MCP is

  • The three primitives

  • The FastMCP server skeleton

  • What the client actually sees

  • Return types

  • Async tools

  • Resources and prompts

  • A complete network-tools server

  • Errors

  • A write tool, the safe way

  • Transports

  • Connecting a host to the server

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 25 — Complete a FastMCP server with three network tools

  • Exercise 25 — Solutions

  • Quiz

  • Quiz 25 — Building an MCP Server with FastMCP

    3 attempts allowed

  • Quiz 25 — Answer key and explanations

  • Lesson 26 — Conversational Agents with LLMs: Chat and Tool Calling

  • Why this matters on the exam

  • The model behind every chat API

  • OpenAI: a cloud model with an API key

  • Multi-turn chat

  • Ollama: a local model on your own host

  • KOHO: choosing between them

  • Tool calling

  • Describing a tool: JSON Schema

  • OpenAI tool calling

  • Ollama tool calling

  • The five differences that decide questions

  • Handling errors

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 26 — Complete the OpenAI and Ollama tool-calling scripts

  • Exercise 26 — Solutions

  • Quiz

  • Quiz 26 — Chat and Tool Calling with OpenAI and Ollama

    3 attempts allowed

  • Quiz 26 — Answer key and explanations

  • Lesson 27 — The Complete Agent Loop for Network Automation

  • Why this matters on the exam

  • The five parts of an agent

  • The loop

  • A safe dispatcher

  • Tracing a run

  • Connecting the agent to MCP tools

  • Guardrails checklist

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 27 — Trace a multi-turn agent run and fix a broken dispatcher

  • Exercise 27 — Solutions

  • Quiz

  • Quiz 27 — The Complete Agent Loop

    3 attempts allowed

  • Quiz 27 — Answer key and explanations

  • Lesson 28 — Evaluating the Accuracy of AI Recommendations

  • Why this matters on the exam

  • Confidence is not correctness

  • Ground: give the model evidence

  • Checking a claim against ground truth in code

  • Validate: test the recommendation before it touches production

  • Measure: trust by numbers

  • An evaluation set

  • Metrics

  • Regression testing for AI

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 28 — Evaluate five AI recommendations against device data

  • Exercise 28 — Solutions

  • Quiz

  • Quiz 28 — Evaluating the Accuracy of AI Recommendations

    3 attempts allowed

  • Quiz 28 — Answer key and explanations

  • Lesson 29 — Integrated Exam Scenarios: Three End-to-End Projects

  • Why this matters on the exam

  • The integrated picture

  • Project 1 — Multi-site VLAN rollout with Ansible

  • Project 2 — OSPF underlay with Terraform

  • Project 3 — Interface descriptions over RESTCONF, validated with pyATS

  • Wiring the three projects into one pipeline

  • Working a lablet

  • The cross-topic distractors that cost the most

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 29 — Lablet walkthrough: a four-part change

  • Exercise 29 — Solutions

  • Quiz

  • Quiz 29 — Integrated Exam Scenarios

    3 attempts allowed

  • Quiz 29 — Answer key and explanations

  • Lesson 30 — Exam Strategy: Answer-Selection Doctrine

  • Why this matters on the exam

  • The three PAC mindsets

  • SPADE: the per-question procedure

  • SPADE on a sample item

  • The Ten Laws of answer selection

  • Twelve tells of a wrong option

  • Question-type playbooks

  • Fill-in-the-blank rules

  • When a question makes no sense: NEXT

  • The guessing ladder: D.R.S.S.

  • Time management

  • Domain 4.0 decoder

  • The eight-minute brain dump

  • The last 72 hours

  • Summary

  • Key Takeaways

  • Exercise

  • Exercise 30 — Apply SPADE to five sample questions

  • Exercise 30 — Solutions

  • Quiz

  • Quiz 30 — Exam Strategy

    3 attempts allowed

  • Quiz 30 — Answer key and explanations

  • Lesson 31 — Final Review and Mock Exam

  • How to use this lesson

  • Compressed review — Domain 1.0: Network Automation (30 %)

  • Ansible (Lessons 02–03)

  • Terraform (Lessons 04–05)

  • RESTCONF and YANG (Lesson 06)

  • Python (Lessons 07–09)

  • Compressed review — Domain 2.0: Infrastructure as Code (30 %)

  • Compressed review — Domain 3.0: Operations (20 %)

  • Compressed review — Domain 4.0: AI in Automation (20 %)

  • The mnemonic pack

  • The brain-dump sheet

  • One page for exam morning

  • Full mock exam

  • Quiz 31 — Full Mock Exam (40 items)

    3 attempts allowed

  • Quiz 31 — Answer key and explanations

  • Scoring and final revision plan

  • Course wrap-up

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earned over $15 million writing, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub