How to Pass the ServiceNow CAD ExamCertified Application Developer
CAD is the developer bridge from platform administration to custom application delivery. This guide follows the CIS-DF-style SNReady pattern: official domain weights, a 4-week plan, Personal Developer Instance labs, scenario drills, common mistakes, and a final readiness gate before you schedule the exam.
About the CAD Exam
The ServiceNow CAD exam validates that you can build maintainable Now Platform applications. Expect scenario questions about where a requirement belongs, which API fits, when code executes, how scope and security affect behavior, and how to move and test changes.
Prerequisites
- ServiceNow CSA certification (recommended)
- 1+ years of ServiceNow development experience
- Strong JavaScript knowledge
Exam Format
- 60 multiple-choice and multiple-select questions
- 90 minutes to complete
- Cut score not published; aim for 80%+ on timed practice
- Heavy emphasis on scripting and implementation judgment
CAD Domain Breakdown
Study time should follow official blueprint weight. Scripting & APIs is the largest domain, but CAD questions often blend scripting with Business Rules, Client Scripts, integrations, and scoped-app lifecycle decisions.
Scripting & APIs
25%High priorityGlideRecord, GlideSystem, GlideAjax, and server-side scripting
- GlideRecord query, insert, update, delete, and encoded-query patterns
- GlideSystem utilities, user/session methods, messages, logging, and debugging
- When to use GlideAjax, GlideAggregate, and server-side scripts instead of client-side code
Business Rules
15%High priorityCreating and managing business rules for server-side automation
- Before, after, async, display, and query rule timing
- current and previous objects, conditions, order, and recursion prevention
- Using display rules and g_scratchpad to prepare data for client scripts
Integration & REST APIs
15%High priorityREST APIs, web services, and external integrations
- Table API versus Scripted REST API decision points
- Outbound REST Messages, authentication, payload parsing, and error handling
- Import Sets, Transform Maps, coalesce fields, and integration data loading
Client Scripts
12%Client-side scripting for form customization and user experience
- onLoad, onChange, onSubmit, and onCellEdit script behavior
- g_form, g_user, and client-side validation limitations
- Choosing GlideAjax when the browser needs server-side data
Script Includes
12%Reusable server-side JavaScript libraries
- Prototype structure, initialize(), type, and reusable server-side classes
- Client-callable Script Includes with AbstractAjaxProcessor and getParameter()
- Scope, accessibility, and cross-scope application access rules
Application Development
11%Studio, scoped applications, and update sets
- Scoped applications, Studio, custom tables, roles, and application files
- Update sets, app repository/source control, deployment, and rollback thinking
- ATF test design, application security, and cross-scope privileges
UI Policies & Actions
10%Dynamically changing form behavior without scripting
- UI Policy conditions, actions, reverse-if-false behavior, and execution order
- When UI Policies are better than Client Scripts for field behavior
- Form buttons, list choices, context menus, and client/server UI Action execution
Domain percentages sourced from the official CAD exam blueprint on NowLearning →
CAD scenario decision matrix
Choose the right ServiceNow development artifact
CAD rarely rewards memorizing one API in isolation. It rewards picking the safest artifact for a requirement, then explaining execution context, maintainability, scope, and data integrity. Use this matrix when reviewing missed questions.
Set or validate a value before a record is saved
Use server-side enforcement for data integrity. A before rule can set values on current; a Data Policy enforces field rules beyond the form.
Before Business Rule or Data Policy
Exam trap: Choosing an after Business Rule and calling current.update(), which can cause recursion or unnecessary writes.
Show, hide, require, or make fields read-only on a form
UI Policies express simple field behavior declaratively and are easier to maintain than script-heavy form logic.
UI Policy first; Client Script when logic is too complex
Exam trap: Using Client Scripts for every form requirement and forgetting reverse-if-false or server-side enforcement needs.
Let a Client Script retrieve server-side data
The browser cannot safely run server APIs directly. GlideAjax keeps server logic reusable while returning only the needed answer.
GlideAjax with a client-callable Script Include
Exam trap: Trying to use GlideRecord in client code or putting sensitive logic in the browser.
Reuse business logic across rules, APIs, and jobs
Script Includes centralize server-side logic, reduce duplicate code, and can be scoped or exposed intentionally.
Script Include
Exam trap: Copying the same code into multiple Business Rules and missing scope or accessibility settings.
Load external records and transform them into a table
Import Sets stage incoming data; Transform Maps handle field mapping, transform scripts, and coalesce behavior.
Import Set + Transform Map
Exam trap: Writing a custom integration before recognizing the built-in staging and transform pattern.
Expose custom server logic to external systems
Scripted REST APIs define resources, HTTP methods, request parsing, response shape, and application-specific behavior.
Scripted REST API
Exam trap: Confusing inbound custom APIs with outbound REST Messages or generic Table API access.
Week-before code pattern checklist
Complete these drills before relying on timed mocks. Each one turns a common CAD vocabulary topic into implementation judgment.
- ✓Write GlideRecord queries with addQuery(), addEncodedQuery(), query(), next(), getValue(), and setValue() until you can predict each result.
- ✓Compare before, after, async, display, and query Business Rules in a table that logs execution order and available objects.
- ✓Build one Client Script that uses g_form only and one that calls GlideAjax, then explain why the second needed a Script Include.
- ✓Create a UI Policy and an equivalent Client Script for the same behavior; document which is easier to audit and maintain.
- ✓Build a Transform Map with coalesce enabled and test what happens when incoming data matches versus creates a record.
- ✓Move a small scoped-app change through update-set or app repository flow, then verify the behavior with an ATF test.
How to Study for CAD
Follow this sequence so JavaScript syntax, platform APIs, execution timing, integrations, and application lifecycle topics reinforce each other.
Take a baseline CAD practice test
Start with a mixed-domain diagnostic to identify whether misses come from JavaScript syntax, ServiceNow API knowledge, execution timing, or application-lifecycle concepts.
Master scripting contexts and GlideRecord
Scripting & APIs is the largest domain. Practice server-side GlideRecord, GlideSystem, GlideAggregate, logging, and safe query patterns until the API choice is automatic.
Learn execution timing for rules and client behavior
Business Rules, Client Scripts, UI Policies, and UI Actions often test when code runs and what objects are available. Build examples for before, after, async, display, onLoad, onChange, and onSubmit behavior.
Build reusable and integrated application logic
Use Script Includes for shared server logic, GlideAjax for client-server calls, REST APIs for integrations, and Import Sets plus Transform Maps for bulk loads.
Practice scoped-app lifecycle and security
Create a scoped app in Studio, configure roles and ACLs, handle cross-scope access, move work with update sets or app repository/source control, and validate behavior with ATF.
Finish with timed mocks and a code-decision miss log
Retake mixed mock exams until you can score 80% or higher twice and explain every miss as an artifact, API, timing, scope, or deployment decision.
4-week study calendar
A realistic CAD prep plan
Scripting foundation and baseline
Make ServiceNow server-side JavaScript and API selection feel predictable.
- Read the CAD blueprint and sort all domains by exam weight.
- Write GlideRecord examples for query, insert, update, delete, addQuery(), addEncodedQuery(), and getValue() versus getDisplayValue().
- Take 30-60 mixed practice questions and create a miss log grouped by API, context, and artifact type.
Automation timing and form behavior
Stop memorizing artifact names and learn when each one executes.
- Build before, after, async, and display Business Rules and note which objects are available.
- Create onLoad, onChange, and onSubmit Client Scripts using g_form and guard clauses such as isLoading.
- Rebuild simple mandatory/visible/read-only behavior as a UI Policy and compare it with scripted client logic.
Reusable logic and integrations
Connect custom application logic to users, clients, and external systems safely.
- Create a Script Include and a client-callable Script Include that extends AbstractAjaxProcessor.
- Build a GlideAjax call from a Client Script and explain getParameter()/answer handling.
- Review Table API, Scripted REST APIs, RESTMessageV2, Import Sets, Transform Maps, and coalesce behavior.
Application lifecycle and exam simulation
Turn coding knowledge into deployable application-development judgment.
- Build or inspect a scoped app with custom tables, application files, roles, ACLs, and cross-scope access decisions.
- Create or review ATF tests and trace how update sets/app repository/source control move changes.
- Take at least two 60-question timed CAD mock exams and remediate every weak domain.
CAD Hands-on Lab Checklist
Do these labs in a ServiceNow Personal Developer Instance. CAD rewards candidates who can reason from actual platform behavior, not only remember definitions.
Scoped app from scratch
Create a scoped application, add a custom table, set a menu/module, create records, and identify which artifacts belong to the app scope.
GlideRecord CRUD and query drill
Write scripts for query, insert, update, delete, addQuery(), addEncodedQuery(), and GlideAggregate so API behavior is muscle memory.
Business Rule execution comparison
Create before, after, async, and display rules and document how current, previous, update behavior, and g_scratchpad differ.
Client behavior decision lab
Implement the same field behavior with a UI Policy and a Client Script, then explain which option is cleaner and why.
GlideAjax and Script Include lab
Create a client-callable Script Include, pass a parameter from the browser, return a value, and explain why GlideRecord cannot run directly in client scripts.
Integration and data-load lab
Inspect Table API versus Scripted REST API use cases, run an outbound REST Message, and trace an Import Set through a Transform Map with a coalesce field.
Security, deployment, and ATF lab
Add roles and ACLs, review cross-scope access, move a change with an update set or app repository flow, and validate a scenario with ATF.
Scenario Drills: Think Like a ServiceNow Developer
CAD questions often ask for the best implementation choice, not a memorized syntax snippet. Practice explaining each decision.
A form field needs to become mandatory when a simple condition is true across desktop and mobile experiences.
Exam test: Do you write a Client Script first, or use a UI Policy?
Strong answer: Prefer a UI Policy for simple mandatory, visible, and read-only behavior. Use a Client Script when the logic truly requires scripting or client-side API calls.
A Client Script needs data that only exists on the server, such as a GlideRecord lookup.
Exam test: Can the browser run GlideRecord directly?
Strong answer: No. Client Scripts run in the browser. Put server logic in a client-callable Script Include and call it asynchronously with GlideAjax.
A related record should be created after an incident is saved, but the current record itself should not be modified before insert.
Exam test: Which Business Rule timing fits?
Strong answer: An after Business Rule is usually appropriate for related-record side effects after the current record is committed. Before rules are better for validating or changing the current record before save.
An integration must expose a custom endpoint that applies business logic before returning data.
Exam test: Table API or Scripted REST API?
Strong answer: Use a Scripted REST API when the endpoint and response require custom logic. Use the Table API when standard table operations are sufficient.
A scoped application script needs to read data from a global table and is blocked.
Exam test: Is this only a JavaScript error?
Strong answer: No. CAD questions often test scope and security. Check application access, cross-scope privileges, ACLs, and whether the target API/table is allowed from the current scope.
Common CAD Mistakes to Avoid
These are the mistakes that turn otherwise good developers into inconsistent CAD exam takers.
Studying JavaScript without ServiceNow context
CAD is not a generic JavaScript exam. Every script runs in a specific ServiceNow artifact with specific objects, timing, and security constraints.
Confusing client-side and server-side APIs
g_form and g_user are client-side. GlideRecord and GlideSystem are server-side. GlideAjax bridges the two when the browser needs server data.
Memorizing Business Rule types without timing
Before, after, async, display, and query rules differ because of when they run and what they can safely change. Scenario questions target that distinction.
Over-scripting simple form behavior
UI Policies and Data Policies exist for predictable field behavior and server-side enforcement. Do not default to Client Scripts for every requirement.
Ignoring scope and security
Scoped apps, cross-scope access, roles, and ACLs are developer concerns. Code that works as admin may fail for real users or from another scope.
Skipping deployment and testing topics
Update sets, app repository/source control, and ATF appear in application lifecycle questions. CAD is about shipping safe apps, not just writing scripts.
Free CAD Practice Questions
A few sample questions from high-impact exam domains. Use the full practice bank to build speed and accuracy.
Which ServiceNow API is used server-side to query and update records in a table?
GlideRecord is the server-side API for querying, inserting, updating, and deleting records. g_form is client-side, while GlideAjax calls server logic from the client.
Which Business Rule timing is best when you need to modify values on the current record before it is saved?
Before Business Rules run before the database operation and can modify current record values without a separate update() call.
A Client Script needs to retrieve server-side data. What pattern should a developer normally use?
Client Scripts cannot run server-side GlideRecord directly. GlideAjax calls a client-callable Script Include to retrieve server data asynchronously.
Which feature is most appropriate when incoming data must be staged before being transformed into a target table?
Import Sets stage incoming data, and Transform Maps define how fields are mapped, transformed, coalesced, and written to target tables.
194 questions · Timed · Instant results
Final CAD Readiness Checklist
If these are not true yet, keep practicing before you pay for the exam. CAD rewards implementation judgment under time pressure.
- ✓Score 80% or higher on two full-length timed CAD mock exams.
- ✓Complete the scoped-app, GlideRecord, Business Rule, client behavior, GlideAjax, integration, security, and ATF labs without step-by-step notes.
- ✓Explain whether each scenario belongs in a Business Rule, Client Script, UI Policy, Data Policy, UI Action, Script Include, REST API, or Transform Map.
- ✓Describe before, after, async, display, onLoad, onChange, and onSubmit execution timing from memory.
- ✓Explain scoped-app access, roles, ACLs, and cross-scope privileges using a real example.
- ✓Review every missed practice question by artifact, API, execution context, and application lifecycle stage.