Originally published on CertLand.
The DevNet Associate exam rewards candidates who understand the full application and network automation stack — not just Python basics or REST APIs in isolation. Many candidates who feel confident about APIs still lose significant points in Domains 4 and 5 (Application Deployment, Infrastructure and Automation) because the questions test specific distinctions: when to use NETCONF vs RESTCONF, what "idempotent" really means, how Docker images differ from containers, and why POST is dangerous to retry. This guide covers the most common traps in these domains. In this guide:
- API and HTTP Traps
- Git and Version Control Traps
- Docker and Container Traps
- Automation and IaC Traps
- Cisco Platform API Traps
API and HTTP Traps
Trap 1 — REST Idempotency: POST Is NOT Idempotent
An HTTP method is idempotent if making the same request multiple times produces the same result with no additional side effects. GET, PUT, and DELETE are idempotent. POST is NOT — each POST call typically creates a new resource. This matters in automation: if a script fails mid-run and retries, calling POST again could create duplicate resources. The exam tests this in "what happens if this API call is retried?" scenarios. Safe answer: use PUT (idempotent full replace) for operations that should be retried; use POST only for initial creation.
Trap 2 — HTTP 401 vs 403: Authentication vs Authorization
HTTP 401 Unauthorized means the request lacks valid authentication credentials — no token provided, or token expired. The client should authenticate and retry. HTTP 403 Forbidden means the credentials are valid and authentication succeeded, but the authenticated user does not have permission to access the requested resource. On exam: 401 = "who are you?" problem; 403 = "you're authenticated but you're not allowed here" problem.
Trap 3 — Webhooks vs Polling: Push vs Pull
Polling means your application periodically sends requests to check if something changed. Webhooks (callbacks) mean the remote service sends a notification to your application when something changes. Polling is simple but wasteful (unnecessary requests when nothing has changed). Webhooks are efficient but require your application to expose a public HTTPS endpoint to receive callbacks. On exam: the "event-driven" or "real-time notification" answer is always webhooks; "periodic check" is polling.
Trap 4 — OAuth 2.0 Flows: Client Credentials vs Authorization Code
OAuth 2.0 has multiple grant types. The two most tested:Authorization Code flowis for web applications where a human user must approve access (user clicks "Allow" in a browser).Client Credentials flowis for server-to-server (machine-to-machine) communication where no user is involved — the application authenticates directly with client ID and secret. DevNet exam question: automation script needs to call an API without human interaction → Client Credentials. Web app needs user to log in → Authorization Code.
Git and Version Control Traps
Trap 5 — git merge vs git rebase: Different History Results
git mergecombines two branches and creates a merge commit — preserves the full branch history and shows where branches diverged and merged.git rebasereplays commits from one branch on top of another — creates a linear history without merge commits. Rebase rewrites history and should NOT be used on shared/public branches. On exam: which command creates a linear history? Rebase. Which preserves branch structure? Merge.
Trap 6 — A Pull Request Is Not a Git Command
This seems obvious but exam questions sometimes test whether candidates understand the distinction.git pullis a Git command that fetches and merges remote changes. A "pull request" (GitHub) or "merge request" (GitLab) is a platform feature — a request for code review before merging a branch into the main branch. The exam may ask about code review workflows — the answer involves pull requests, not git pull commands.
Docker and Container Traps
Trap 7 — Docker Image vs Container vs Registry
- Image:A read-only template containing the application, dependencies, and instructions. Built from a Dockerfile. Stored in a registry.
- Container:A running instance of an image. Containers are ephemeral — data written inside a container is lost when it stops unless volumes are used.
- Registry:Storage for images. Docker Hub is the public registry; private registries are common in enterprise environments.
On exam: "Which is immutable?" → Image. "Which is ephemeral?" → Container. "Where are images stored?" → Registry.
Trap 8 — Dockerfile CMD vs ENTRYPOINT
CMDprovides default arguments that can be overridden when running the container:docker run myimage custom-argreplaces CMD.ENTRYPOINTdefines the main executable and cannot be overridden by default (requires--entrypointflag to override). Best practice: use ENTRYPOINT for the executable, CMD for default arguments. On exam: which Dockerfile instruction sets the main process that cannot be easily overridden? ENTRYPOINT.
Automation and IaC Traps
Trap 9 — Ansible Is Agentless; Puppet Is Agent-Based
Ansible uses SSH (Linux) or WinRM (Windows) to connect to managed nodes — no agent software installed on targets. This is the "agentless" model and is its key selling point for network automation (network devices rarely support agent software). Ansible uses a push model: the control node pushes configuration to targets. Puppet uses an agent installed on each managed node that periodically pulls configuration from a Puppet master. On exam: no agent required = Ansible; agent installed on nodes = Puppet/Chef.
Trap 10 — Ansible Idempotency: Tasks Should Be Safe to Run Multiple Times
Ansible playbooks should be idempotent — running the same playbook twice should produce the same result without creating duplicates or errors. Ansible modules designed for network devices (cisco.ios, cisco.nxos) are idempotent: if the desired state already exists, no change is made. On exam questions about "what is a key benefit of Ansible for network automation?" — idempotency (safe reruns) is a core answer.
Trap 11 — CI/CD: What Each Stage Does
Continuous Integration (CI): Developers frequently merge code to a shared branch. Automated builds and tests run on each commit to catch integration issues early. Continuous Delivery/Deployment (CD): After CI passes, the application is automatically prepared (delivery) or deployed (deployment) to production. Key distinction: CD with delivery requires human approval to deploy; CD with deployment deploys automatically. On exam: "commits trigger automated tests" = CI; "deploy to production automatically" = Continuous Deployment.
Cisco Platform API Traps
Trap 12 — NETCONF Uses TCP Port 830, Not 22 or 80
NETCONF operates over SSH (Secure Shell) but uses a dedicated port: TCP 830 (not the standard SSH port 22). This is specifically tested. RESTCONF uses standard HTTPS (TCP 443). On exam: NETCONF = TCP 830; RESTCONF = TCP 443 (HTTPS). The confusion arises because NETCONF uses SSH as transport — candidates assume port 22, but 830 is the IANA-assigned port for NETCONF over SSH.
Trap 13 — DNA Center (Catalyst Center) API Requires Token, Not Basic Auth for All Calls
The Cisco DNA Center/Catalyst Center API uses token-based authentication. You make one POST call with Basic Auth (username/password) to get a token, then use that token for all subsequent API calls via theX-Auth-Tokenheader. The token is temporary. On exam: what authentication is used for all DNA Center API calls after login? Token-based, not Basic Auth. Basic Auth is only used for the initial token request.
Ready to Practice?
Our 340-question DevNet Associate practice exam tests every trap in this guide with detailed explanations. Practice DevNet Now →
Top comments (0)