CCNA Automation Domain 1: Software Development and Design (15%)

Overview

Software Development and Design carries 15% of the 200-901 CCNAAUTO exam and has eight objectives. Objectives 1.1 and 1.2 compare XML, JSON and YAML and describe how each is parsed into Python dictionaries and lists. Objective 1.3 covers test-driven development, and 1.4 compares agile, lean and waterfall. Objectives 1.5 and 1.6 explain why code is split into functions, classes and modules, and what the MVC and Observer patterns offer. Objectives 1.7 and 1.8 cover version control and the Git operations clone, add, remove, commit, push, pull, branch, merge and diff.

This exam was called DevNet Associate (DEVASC) until 3 February 2026, when Cisco renamed the DevNet track to CCNA, CCNP and CCIE Automation. The exam number stayed 200-901, current holders were moved across automatically, and the topics here come from the v1.1 blueprint.

Why it matters on the exam

Every later domain assumes you can read structured data and a short Python program. An API returns JSON, a RESTCONF query returns XML or JSON, and an Ansible playbook is YAML, so a candidate who cannot tell which bracket or indentation rule applies will misread answers in Domains 2, 3 and 5 as well. Git is equally pervasive: infrastructure as code, code review and CI/CD in later domains all assume branches, commits and merges. The domain is also where network engineers without a programming background lose easy marks, because the questions reward precise knowledge of small details such as how a JSON array maps to a Python list or what git pull actually does. If you are still studying from DevNet Associate material, the blueprint content carries over, but expect current Cisco product names elsewhere in the exam.

How it's tested

Questions in this domain usually show a short snippet of data, Python or Git output and ask what it means or what comes next. Some are drag-and-drop items that match a methodology or pattern to its description. Read snippets slowly, because a single bracket or flag usually decides the answer.

Snippet to structure

A JSON, XML or YAML block is shown and you choose the Python expression that extracts a given value.
Method or pattern match

A team's way of working or a code layout is described, and you name the methodology or design pattern.
Git sequence

A workflow goal such as publishing a feature branch is given, and you order or pick the Git commands that achieve it.

Reasoning it through

A stem shows JSON with a key named interfaces holding an array of objects, each with a name key, and asks for the Python expression returning the second interface name after json.loads. The array becomes a list and each object a dictionary, so indexing starts at zero: data['interfaces'][1]['name']. Options using [2] or attribute dot notation are wrong.

Objectives 8

Official objectives from the Cisco outline, in outline order.

1.1 Compare data formats (XML, JSON, and YAML)Syntax, structure and typical uses of the three formats.

What it means: XML uses opening and closing tags, attributes and namespaces, and is the encoding NETCONF uses. JSON uses braces for objects, square brackets for arrays and double-quoted keys, and is the default for most REST APIs. YAML expresses the same data with indentation, dashes for list items and colons for key-value pairs, and is the format of Ansible playbooks.
What to understand: All three describe nested key-value data, so the comparison is about syntax and where each appears. JSON does not allow comments or trailing commas and requires double quotes. YAML is whitespace-sensitive, permits comments with a hash and is a superset of JSON. XML is the most verbose but supports attributes and schemas. Knowing which format a tool expects helps eliminate wrong answers quickly.
How it shows up: Identify the format of a snippet, or spot the syntax error such as single quotes in JSON or a tab in YAML.
Common confusion: Assuming YAML lists use brackets like JSON; YAML block lists use leading dashes.

1.2 Describe parsing of common data format (XML, JSON, and YAML) to Python data structuresHow json, yaml and XML libraries turn text into dictionaries and lists.

What it means: Python's json module loads text with json.loads or a file with json.load and writes with json.dumps. PyYAML provides yaml.safe_load. XML is commonly parsed with xmltodict, which returns nested dictionaries, or with ElementTree, which returns element objects.
What to understand: After parsing, a JSON or YAML object becomes a dict and an array becomes a list, so values are reached by chaining keys and zero-based indexes. Strings, numbers, booleans and null map to str, int or float, True or False, and None. With xmltodict, attributes appear as keys prefixed with @ and text content under #text. The exam expects you to write or recognise the correct access path.
How it shows up: Choose the line of Python that returns a specific value from a parsed payload.
Common confusion: Mixing up loads (string) and load (file object), or dumps and loads.

1.3 Describe the concepts of test-driven developmentWriting a failing test before the code that makes it pass.

What it means: Test-driven development is a cycle: write a test for the next small piece of behaviour, run it and watch it fail, write the minimum code to make it pass, then refactor while keeping tests green.
What to understand: TDD forces requirements to be stated as tests before implementation, which gives fast feedback and a regression suite that grows with the code. The order matters on the exam: red, green, refactor. It does not mean testing after the code is finished, and it does not replace integration testing.
How it shows up: Order the TDD steps, or identify which step comes after a test fails for the first time.
Common confusion: Writing the full feature first and adding tests later is not TDD.

1.4 Compare software development methods (agile, lean, and waterfall)Sequential versus iterative ways of delivering software.

What it means: Waterfall runs fixed phases in sequence: requirements, design, implementation, verification and maintenance. Agile delivers working software in short iterations or sprints with continual customer feedback. Lean focuses on removing waste, delivering value quickly and improving the flow of work.
What to understand: Waterfall suits projects with stable, well-understood requirements but makes late changes expensive. Agile accepts changing requirements and values working software and collaboration over heavy documentation; Scrum is one agile framework. Lean, which came from manufacturing, is about eliminating anything that does not add customer value, such as waiting or partially finished work.
How it shows up: A project description is given, and you choose the method that matches it.
Common confusion: Treating agile and lean as identical; they overlap, but lean centres on waste and flow.

1.5 Explain the benefits of organizing code into methods / functions, classes, and modulesModularity, reuse and readability in Python code.

What it means: Functions package a block of logic under a name with parameters and a return value. Classes bundle data and the methods that act on it, and objects are instances of classes. Modules are .py files whose functions and classes can be imported by other code.
What to understand: Breaking code into these units avoids duplication, makes each piece easier to test in isolation, and lets teams reuse code across projects. A method is a function defined inside a class. Packages group related modules in a directory. Questions often present a repetitive script and ask what refactoring would improve it.
How it shows up: Pick the benefit of moving repeated logic into a function or module.
Common confusion: Calling every function a method; methods belong to a class.

1.6 Explain the advantages of common design patterns (MVC and Observer)Two reusable software structures and why they help.

What it means: Model-View-Controller separates the data and business logic (model), the presentation (view) and the input handling that connects them (controller). The Observer pattern lets a subject keep a list of observers and notify them automatically when its state changes.
What to understand: MVC lets developers change the user interface without rewriting business logic and lets several views share one model. Observer decouples the source of an event from the code reacting to it, which is the idea behind publish-subscribe and webhooks. Exam items describe a behaviour and ask which pattern it is.
How it shows up: Match a description such as 'subscribers are notified when data changes' to Observer.
Common confusion: Assigning business rules to the view or the controller instead of the model.

1.7 Explain the advantages of version controlWhy tracking changes in a repository matters.

What it means: Version control records every change to files with author, time and message, so teams can see history, compare versions, roll back mistakes and work in parallel.
What to understand: Distributed systems like Git give every developer a full copy of the history, so work continues offline and there is no single point of failure. Branching lets features develop in isolation, and merges bring them together. Version control is also the foundation for code review and CI/CD triggers.
How it shows up: Choose the main benefit of version control for a team editing the same automation scripts.
Common confusion: Thinking version control is only a backup; its value is history, collaboration and controlled change.

1.8 Utilize common version control operations with GitClone, add/remove, commit, push/pull, branch, merge and conflict handling, diff.

What it means: git clone copies a remote repository locally. git add stages changes and git rm stages a deletion. git commit records staged changes. git push sends commits to a remote and git pull fetches and merges remote changes. git branch and git checkout or switch create and move between branches, git merge combines branches, and git diff shows line-level differences.
What to understand: Git has three local areas: the working directory, the staging area (index) and the repository. Changes must be added before they can be committed. A merge conflict happens when two branches change the same lines; Git marks the file with <<<<<<<, ======= and >>>>>>> and you edit, add and commit to resolve it. git diff with no arguments compares working tree to index, and git diff --staged compares index to the last commit.
How it shows up: Order commands to publish a new branch, or explain what a conflict marker means.
Common confusion: Believing git commit sends work to the remote; only push does that.

High-yield concepts

The terms, rules and formulas this domain turns into questions most often.

JSON syntax rules

Objects in braces, arrays in brackets, keys and strings in double quotes.

Remember
No comments and no trailing commas.

Tested as
Spot-the-error snippet items.

Trap
Accepting single-quoted keys as valid JSON.
YAML indentation

Structure is defined by spaces; dashes mark list items.

Remember
Tabs are not allowed for indentation.

Tested as
Reading Ansible and config snippets.

Trap
Assuming indentation is cosmetic.
json.loads vs json.load

loads parses a string; load reads a file object.

Remember
The s stands for string.

Tested as
Code-completion questions.

Trap
Passing a filename string to json.load.
xmltodict

Converts XML into nested dictionaries.

Remember
Attributes become keys starting with @.

Tested as
Parsing NETCONF replies in Python.

Trap
Expecting attribute names without the @ prefix.
Red, green, refactor

The three-step TDD loop.

Remember
The test is written and fails before the code exists.

Tested as
Ordering questions.

Trap
Putting refactor before green.
Waterfall

Sequential phases with sign-off between them.

Remember
Change late in the project is costly.

Tested as
Methodology matching.

Trap
Choosing it for projects with shifting requirements.
Observer pattern

Subject notifies registered observers on change.

Remember
Basis for publish-subscribe and event callbacks.

Tested as
Pattern identification.

Trap
Confusing it with MVC's controller.
Git staging area

Holds changes selected for the next commit.

Remember
add moves changes into it; commit records it.

Tested as
Command sequence questions.

Trap
Skipping add and expecting commit to include edits.
git pull

Fetches from the remote and merges into the current branch.

Remember
pull equals fetch plus merge.

Tested as
Choosing between fetch and pull.

Trap
Thinking pull only downloads without merging.
Merge conflict markers

Lines between <<<<<<< and >>>>>>> show both versions.

Remember
Resolve, then add and commit.

Tested as
Interpreting conflicted files.

Trap
Assuming Git picks a winner automatically.

Side by side

Concepts candidates mix up, compared on the point that decides the answer.

Data formats

Concept	Meaning	Key difference	Common trap
XML	Tag-based markup with attributes	Verbose; used by NETCONF	Forgetting attributes when parsing
JSON	Braces and brackets with quoted keys	Default REST payload format	Using single quotes or comments
YAML	Indentation-based, human-friendly	Used by Ansible; allows comments	Mixing tabs and spaces

Development methods

Concept	Meaning	Key difference	Common trap
Waterfall	Fixed sequential phases	Plan everything up front	Assuming it handles change cheaply
Agile	Short iterations with feedback	Embraces changing requirements	Equating agile with no planning
Lean	Eliminate waste, optimise flow	Focus on value and flow	Treating it as a synonym for Scrum

Git sync commands

Concept	Meaning	Key difference	Common trap
git fetch	Downloads remote commits only	Leaves your branch unchanged	Expecting files to update
git pull	Fetch plus merge	Updates the current branch	Using it when you only want to inspect
git push	Uploads local commits	Requires commits first	Pushing before committing

Exam traps

Each trap is an answer that looks right. Learn the clue that should change your mind.

Format identification

What candidates pick
JSON for any snippet with colons

Why it looks right
Both JSON and YAML use key: value pairs

Why it's wrong
A snippet without braces, using indentation and dashes, is YAML even though colons appear.

Clue to watch for Look for braces and quoted keys versus indentation and dashes.
Parsing function

What candidates pick
json.load(string_variable)

Why it looks right
The name looks right for loading JSON

Why it's wrong
json.load expects a file-like object; a string needs json.loads.

Clue to watch for Check whether the input is a string or an open file.
TDD order

What candidates pick
Write code, then write tests

Why it looks right
It matches how many people actually work

Why it's wrong
TDD requires the failing test first, which defines the behaviour before implementation.

Clue to watch for The word 'first' or 'before' in the stem.
Pattern naming

What candidates pick
MVC for any event-notification design

Why it looks right
MVC is the better-known pattern

Why it's wrong
Notifying subscribers when state changes is the Observer pattern; MVC is about separating concerns.

Clue to watch for Words like subscribe, notify or listener.
Publishing changes

What candidates pick
git commit

Why it looks right
Commit feels like the final step

Why it's wrong
Commit records locally; nothing reaches the remote until git push runs.

Clue to watch for The stem mentions a shared or remote repository.

Answer framework

Use these steps when a question shows data, code or a Git scenario and asks what happens or what to do next.

Identify the artefact first: decide whether the snippet is XML, JSON, YAML, Python or Git output by its brackets, tags, indentation or prompt.
Map the structure to Python types, treating objects as dictionaries and arrays as lists, and trace the exact key and index path requested.
For process questions, look for clues about fixed phases, short iterations or waste reduction, and match them to waterfall, agile or lean.
For design questions, ask whether the stem separates data from presentation, which suggests MVC, or describes notifications, which suggests Observer.
For Git items, track which area each change is in (working tree, staging area, local repository or remote) before picking the command.

Practice question

An engineer edits two Python scripts in a cloned repository, runs git add on one of them and then runs git commit -m 'update'. A colleague then clones the remote. What does the colleague see?

Both edited scripts, because commit records all modified files Only the staged script, because commit includes staged changes Neither change, because the commit exists only in the engineer's local repository A merge conflict, because one file was committed and the other was not

Show the answer

Answer C. git commit records only staged changes, and it records them in the local repository. No git push was run, so the remote is unchanged and a fresh clone contains neither edit. The staged-script option correctly describes what the local commit contains but ignores that it never left the engineer's machine. Unstaged edits do not cause conflicts, and commit never sweeps in unstaged files unless the -a flag is used.

Want more like this? The CCNA Automation practice test has questions for every domain.

Checklist

0 of 11

Tick each one you can do without notes. Your ticks stay in this browser.

Study strategy

Spend most of this domain's time at a keyboard. Install Python and Git, then take a sample JSON response from any public API and practise reaching nested values with keys and indexes until it is automatic. Convert the same data to YAML and XML by hand, parse each back into Python with json, PyYAML and xmltodict, and compare the resulting structures. This builds the reading speed that Domains 2, 3 and 5 also need.

For Git, create a throwaway repository, make two branches that change the same line, merge them and resolve the conflict yourself. Run git status after every command so you see files move between the working tree, staging area and repository. The theory objectives on TDD, development methods and design patterns need less time: one page of notes per topic is enough, focused on distinguishing features. Finish with timed questions that show snippets, because recognising a format or command under time pressure is the real skill. Revisit any snippet you misread rather than only the concept behind it.

FAQ

How much of the CCNA Automation exam is Software Development and Design?

Software Development and Design is 15% of the 200-901 CCNAAUTO exam, with eight official objectives covering data formats, parsing, TDD, development methods, code organisation, design patterns and Git.

Do I need to write Python from scratch for this domain?

You need to read and complete short Python snippets, especially parsing code. Writing longer programs is not required here, but Domains 2 and 3 do ask you to construct scripts using requests or a Cisco SDK.

Which Git commands are listed in the blueprint?

Objective 1.8 lists clone, add and remove, commit, push and pull, branch, merge and handling conflicts, and diff.

Is this domain different from the old DevNet Associate version?

The domain name, weight and Git and data-format topics are the same as in the DEVASC blueprint. The certification name changed to CCNA Automation on 3 February 2026.

Which Python libraries should I know for parsing?

Know the standard json module, PyYAML's safe_load for YAML, and xmltodict or ElementTree for XML.

How deep do the design pattern questions go?

They test recognition: what MVC separates and what problem Observer solves. You will not be asked to implement either pattern.

Related domains

Other Networking certifications

Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.

CCNA Automation Domain 1: Software Development and Design

Overview

How it's tested

Snippet to structure

Method or pattern match

Git sequence

Objectives 8

High-yield concepts

JSON syntax rules

YAML indentation

json.loads vs json.load

xmltodict

Red, green, refactor

Waterfall

Observer pattern

Git staging area

git pull

Merge conflict markers

Side by side

Data formats

Development methods

Git sync commands

Exam traps

Format identification

Parsing function

TDD order

Pattern naming

Publishing changes

Answer framework

Practice question

Checklist

Study strategy

FAQ

Other Networking certifications

Test your Domain 1 knowledge

Keep going