Browser-first course · For working network engineers
Make the change with code, prove it worked, and hand it to the next engineer.
You take one reported network problem and work it through to a tested tool: gather the facts, write the code, push the change, validate it deployed, and leave a record the next engineer can use. AI can accelerate drafting, but you keep responsibility for the decision and the proof.
The first 10 lessons are free with a local account. No email address is required.
- 10
- free foundation lessons
- 32
- graded paid lessons
- 10
- paid course modules
- $249
- lifetime access
Learning objectives
What you will be able to do
- Write a script that talks to devices and fails loudly when something is wrong.
- Catch a bad AI-generated change before it reaches a device.
- Leave a run record another engineer can easily read.
Key outcomes
What you leave with
A tested automation tool
It discovers network state, makes the change, and checks the result against what you said would happen.
A rollback you have run
The revert is graded too, so you prove it works before anyone needs it.
A run record
Each stage of the change reports pass or fail: discover, push, validate, roll back, record.
A clean handoff
The next engineer gets the tool, the record, and a written boundary of what it supports.
Try it first
Try it free, then decide
The free foundation track teaches Python through network text, files, inventories, and test output. Its labs use the same browser editor and deterministic checks as the paid course.
The first 10 lessons and their graded labs are free with a local account. If the delivery fits how you want to practice, the paid course contains 35 navigable lessons, including 32 graded lessons, for $249 one time with lifetime access and a 7-day refund window.
Start with the real browser grader before deciding whether to buy the paid course.
Built on experience
The course teaches the change loop end to end.
The work is completed in two halves: assessing an environment, and code that validates itself. A working network engineer already has the experience and skills. This course teaches the evolving part of the job: Python against real device output, changes validated before and after, version control as a habit & process, device APIs beyond the CLI, and AI you supervise instead of trust.
What you know
You can read a network, identify what a change might break, and stay in-the-know when the plan changes. The course builds on this instead of starting you over.
What you practice
You run the full loop on a simulated network: discover the topology, push a change built from data, validate it deployed, and roll it back against criteria you wrote down in advance.
What you can prove
Working code, passing checks, version history, and a run record another engineer can read.
How the course works
One guided case, then an independent transfer
You begin with enough Python to read and change the course tools. The district-office case then carries one problem through discovery, configuration, validation, source ownership, device APIs, supported tooling, and an approved production workflow.
The warehouse capstone changes the evidence and work constraints. You must build the chain again, reject unsupported controller and firmware claims, route physical work to facilities, remove an orphan dashboard, and hand the bounded result to an operator. Every required grade comes from deterministic checks in the browser.
The labs
What a graded lab looks like
This is the lab from lesson 1 of the free track, running on this page with the same grader the course uses. Pick how much support you want: Guided starts with code one line short of passing, Partial leaves one function for you to write, and Minimal is the untouched lesson starter. The five checks are the same on every level.
The five functions below work on the strings a network engineer pulls from a switch: show version lines, IP octets, and hostnames. You do not enter any device data yourself. Run checks calls each function with sample output and compares what comes back to the expected value.
Four of the five functions are already correct. clean_hostname is missing one method call. Run the checks, read the failure, then fix that line and run again.
Four of the five functions are already correct. Write the body of clean_hostname. Its docstring shows an example of the input and the expected result.
This is the untouched starter from lesson 1. Each docstring says what its function must return. Implement all five functions, then run the checks.
The failing check expects the hostname lowercased. clean_hostname strips the whitespace but never lowercases the result.
return raw.strip().lower()
Chain two string methods on raw. One removes the surrounding whitespace, and one lowercases what is left.
return raw.strip().lower()
"""Lesson 1 reference solutions.
Read these AFTER an honest attempt, then close the file and retype your
own version from memory. The typing is part of the learning.
"""
def extract_serial(line):
return line.split()[3]
def octets_to_ip(octets):
return ".".join(octets)
def clean_hostname(raw):
return raw.strip().lower()
def device_row(hostname, ip):
return f"{hostname:<20} {ip:>18}"
def has_board_id(line):
return "Processor board ID" in line
Each graded paid lesson has at least one required browser lab. Some labs check technical functions, some also check delivery records, and Lesson 06 has two required parts. You can rerun a grader after every edit.
Standards
How the course is built
A written teaching standard
Quiz options carry a reason they are right or wrong. Worked examples create a place to predict or explain before the answer appears. Practice ends with a check that could have failed.
Deterministic grading
Grades come from a test suite running your code in your browser. The same code gets the same grade every time. No AI service judges your work, and no timer or view count is involved.
Published corrections
Every change that affects what a lesson teaches is listed on thecourse updates page, dated, newest first. The page also records corrections. Two lesson diagrams were corrected in August, and the entry explains what was wrong.
Course map
What the modules cover
- F1Core Language for Network Data
- F2From Scripts to a Package
- 00Start Here
- 01Just Enough Python
- 02The Day-One Automation Loop
- 03Keep a Human in the Loop
- 04Build With AI
- 05Source of Truth and Git
- 06Device APIs
- 07From Scripts to Tools
- 08Run It for Real
- 09The Read-First Agent
Free foundation track
The free track has 10 lessons in 2 modules, free with a local account.
01Core Language for Network Data
Learn the Python core through network text. Parse show output with strings and regular expressions, do subnet math, read configuration from files, and model inventories with dictionaries and sets. Each lesson has a graded browser lab.
- Why Python, the REPL, and Strings
- Numbers, Files, and Lists
- Conditionals and Loops
- Dictionaries, Sets, and Exceptions
- Regular Expressions for Show Output
02From Scripts to a Package
Turn working code into tooling you can keep. Write functions with contracts, build device classes with inheritance, and use the Python library ecosystem. The capstone assembles the work into netaudit, an audit package with a command-line interface.
- Functions: Refactoring Your Parsers
- Classes and Objects, Part 1
- Classes and Objects, Part 2
- Libraries, pip, and Virtual Environments
- Modules, Packages, and the Capstone
The paid course
The paid course has 35 navigable lessons in 10 modules, and 32 of those lessons are graded. Its modules are numbered 0 through 9, so Start Here is module 0 of the paid course.
00Start Here
Understand the course promise, the browser-first path, and the Network FDE role boundary. Network FDE here means you own the change from the first ticket through proof and handoff, not just the script. You will see how the pages and labs work, when optional local tools help, and which parts of the job this course cannot reproduce.
- How This Course Works
- The Network FDE Role
01Just Enough Python
Learn the Python used later in the course through network records and saved output. The placement check lets an experienced Python reader move ahead. The first graded record keeps a staff report separate from a measured fact, then the module covers files, JSON, functions, and test output.
- Can You Skip This Module?
- Python: First Contact
- Data Shapes: Lists, Dicts, and JSON
- Loops, Decisions, and Functions
- Your Working Environment
02The Day-One Automation Loop
You run your first complete delivery loop on a fabricated district-office network. You sort the reported complaints from the measured facts, write down the morning authentication problem with a baseline and a target, then crawl LLDP, generate a topology you can review, and push a firewall-policy change. You validate it deployed without breaking anything else, and you hand the follow-up ticket to the help desk lead. Every required check runs in the browser.
- Discover and Document a Network from One IP
- Push Config from Data, and Prove It Deployed
- Validate a Change Before and After
- Side Quest: Mermaid Network Diagrams as CodeFree
03Keep a Human in the Loop
Check claims against evidence and route each failure to the role that can act. The module covers secret handling, traceback reading, data-shape errors, logic bugs, environment diagnosis, verification, and undo. You also classify code, data, environment, process, training, staffing, and vendor work, then record the next owner.
- Secrets, Credentials, and Safe AI Usage
- Read the Traceback, Find the Real Line
- Judge the Shape: Dicts, Nested Dicts, and JSON
- Spot the Bug You Didn't Write
- Is It the Code or the Environment?
- The Verification Habit (and Git as Undo)
- Side Quest - Bug Swarm: The Human-in-the-Loop ArcadeFree
04Build With AI
Write down what the tool must do before asking a model for code: the problem it solves, its inputs and output, what happens on error, how you will accept it, and what stays out of version one. Then you check the candidate code and decide which actions can run on their own, which need approval, and which stay human work.
- Working with an AI Assistant: the Loop
- Vibe-Code a Tool with AI, and Verify It
- Token Economics: Run Your Assistant Like a Network
05Source of Truth and Git
Turn measured network state into a source of truth with an owner, a seven-day freshness limit, and a boundary between observed state and approved intent. Git keeps the history. You compare later discovery with the record, trace changes, restore an earlier standard, and assign freshness ownership after handoff.
- Feed What You Discover into a Source of Truth
- Version the Source of Truth in Git
06Device APIs
Read state over RESTCONF, stream telemetry with gNMI, and make transactional changes over NETCONF. Compare the interfaces against access, data quality, licensing, maintenance-window approval, rollback, and shared dependencies before selecting one for delivery.
- Talk to Devices over REST and RESTCONF
- Stream Telemetry with gNMI
- Change Safely with NETCONF and Confirmed Commit
07From Scripts to Tools
Turn a working script into a tool another operator can run and support. Record the operator, maintainer, support boundary, adoption evidence, work trace, and version-one exclusions. Then structure the repository, write tests, make repeat runs safe, and return useful failure information.
- Project Structure for Automation Tools
- Testing Beyond the Lab
- Idempotency as a Discipline
- Error Handling for Automation
08Run It for Real
Plan and record an approved production change. Separate acceptance checks from operational outcomes, establish approval and rollback before the window, assess new requests against scope, run a canary-first rollout, and retain a redacted run record. The handoff includes the runbook, support boundary, and remeasurement schedule.
- Change Workflow: Dry Run to Rollback
- Logging, Run Records, and Audit Trails
- Package It: Docker for Automation Tools
09The Read-First Agent
You finish the course on an independent warehouse transfer task, working with a read-first agent. You decide what the problem is, what the tool may do, how the change gets approved and rolled back, and who owns it after you. The labs grade those decisions.
- The Read-First Agent
- ChatOps: Human Approval for Agent Writes
Course updates
Corrections and additions after purchase
Every change that affects what a lesson teaches is listed on the course updates page, dated and newest first. Buyers receive those corrections and additions at no extra cost. These are the most recent entries.
- Aug 2026Twenty-seven lessons picked up an illustration, nine picked up a diagram, and twenty-nine picked up reference tables. Nothing was removed to make room.
- Aug 2026Every diagram in the course can now be opened full screen.
- Aug 2026Two lesson diagrams were corrected, and the write-ups say exactly what was wrong with them.
What you bring
Networking knowledge and a current browser
You need
- Comfort with everyday network concepts and command output.
- A current desktop version of Chrome or Safari with JavaScript, WebAssembly, and Web Workers enabled.
- A RouteSwitchU account for the free and paid lessons.
You do not need
- Prior Python development experience.
- Network lab hardware, device licenses, or a cloud account.
- A local Python, Git, Docker, editor, terminal, or ZIP archive for required labs.
- An AI assistant or paid AI plan to pass a lab.
Enrollment
What $249 buys
The complete course is $249, paid once through Stripe Checkout from your account page. There is no subscription and nothing expires.
AI-Assisted Network Automation
$249 · one payment · lifetime access
- All 45 navigable lessons across the free track and the paid course, with 10 free foundation lessons and 35 paid course lessons in 10 paid modules.
- 32 graded paid lessons with required browser checks. Lesson 06 has two required lab parts.
- Authored tests check technical code and delivery records against each lesson's fixed contract.
- Lifetime access, including every correction and every new module added after you buy.
Refund requests are accepted within 7 days of purchase. After 7 days, all sales are final. The 10 free lessons stay free either way, so you can run a real lab on this pagebefore spending anything. The Terms of Sale are shown before you pay.
Questions
Before you begin
Does the course teach Python from scratch?
It opens with a focused Python module covering exactly what the later automation work uses. An experienced Python reader can take a placement check and skip ahead.
Will the labs touch my network?
No. The browser labs use deterministic fixtures and simulated devices. Optional extensions explain how the same patterns connect to real gear, but nothing targets it by default.
Do I have to use ChatGPT, Claude, or Copilot?
No specific assistant is required. The method is model-agnostic, and every graded check runs in your browser without an AI service.
How do I buy the course?
Create or sign in to your RouteSwitchU account to see the purchase option. Payment is handled by Stripe Checkout, and access is attached to that account after confirmed payment.
What is the refund policy?
Refund requests are accepted within 7 days of purchase. After 7 days, all sales are final. If you are not sure, start with the 10 free lessons. They use the same browser editor and deterministic grader as the paid course.
How much time does this take?
We have not timed the lessons, so there is no honest hours number to give you. Length varies with the objective, and some labs take real work. The course is built to fit around a job: progress saves as you go, access does not expire, and there is no weekly schedule.
What does lifetime access mean?
You pay once and keep access. Every correction and every module added after your purchase is included at no extra cost. The course updates page lists each correction and addition by date.
Will this help me at work or in a job search?
The course does not make a hiring claim. You leave with checked work in Python, device APIs, source control, and change control, the kind of work you can paste into a change ticket. Whether that maps to a job title is your employer's call.
Who is this course not for?
If you already write Python at work every day and use device APIs comfortably, the early modules will include familiar mechanisms. The course assumes working knowledge of subnets, configuration, and command output. Build that networking foundation before using this course for automation delivery.