Knowledge + Practice

ServiceNow Certified Application Developer CAD (SNOW-CAD) — Questions 301–375

481 questions total · 7pages · All types, answers revealed

Take a mock exam Exam hub

Page 5 of 7

301

MCQeasy

A developer needs to import user records from a CSV file. The CSV contains a field 'department' that should map to a reference field 'department' on the sys_user table. However, the CSV contains department names, not sys_ids. What is the best approach to map the department names to the correct sys_ids?

A.Set a default value for the department field in the transform map.

B.Use a coalesce field mapping on the department field.

C.Add a reference qualifier to the department field in the target table.

D.Use a transform script to query the department table and set the reference field.

AnswerD

This is the correct approach as it allows dynamic lookup of the sys_id.

Why this answer

A transform script allows you to write custom logic to query the department table and retrieve the sys_id based on the department name from the CSV. Option A (default value) would set a static value for all records, not map dynamically. Option B (coalesce) is used for deduplication during import, not for field mapping.

Option C (reference qualifier) filters the reference picker in forms but does not affect import mapping.

Full explanation →

302

Matchingmedium

Match each ServiceNow REST API method to its CRUD equivalent.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Read

Create

Update (full replacement)

Update (partial)

Delete

Why these pairings

Standard REST methods map to CRUD as follows: GET (Read), POST (Create), PUT (Update), DELETE (Delete). PATCH is often confused with PUT but is for partial updates, and HEAD is for metadata retrieval.

Full explanation →

303

Multi-Selectmedium

A developer wants to use a script include to reuse logic across multiple business rules. Which two considerations should be made? (Choose two.)

Select 2 answers

A.Script includes cannot call other script includes.

B.Script includes should not have side effects on current record.

C.Script includes must be global to be accessible from all scopes.

D.Script includes can be scoped and still accessible from business rules in the same scope.

E.Script includes are automatically evaluated at server start.

AnswersB, D

Correct because script includes should not have side effects on current record to maintain reusability.

Why this answer

Options B and D are correct. B: Script includes should not have side effects on current record to maintain reusability. D: Script includes can be scoped and still accessible from business rules in the same scope.

A is incorrect because script includes can call other script includes. C is incorrect because script includes do not need to be global; they can be scoped. E is incorrect because they are not auto-evaluated.

Full explanation →

304

MCQhard

A developer is troubleshooting a business rule in a scoped application that is not triggering. The rule is set to run 'before' query, with condition 'current.state == 1'. The table has read ACLs that restrict access. What is the most likely reason the business rule is not executing?

A.The condition 'current.state == 1' is incorrect syntax.

B.Another business rule with higher order is preventing execution.

C.The user does not have read access to the records, so the query does not execute the rule.

D.The business rule is scoped and cannot access the table.

AnswerC

Before query rules run only if the user can access the records.

Why this answer

Business rules that run 'before query' execute when a query is made against the table. If the user lacks read access due to ACL restrictions, the query itself is not permitted, so the business rule never triggers. This is because the platform's security layer evaluates ACLs before executing business rules, preventing the rule from running when the user cannot read the records.

Exam trap

ServiceNow often tests the misconception that business rules always execute regardless of security, when in fact ACLs are evaluated first and can prevent the rule from firing entirely.

How to eliminate wrong answers

Option A is wrong because 'current.state == 1' is valid syntax for comparing a field value in a business rule condition; the double equals is correct for equality checks. Option B is wrong because business rules with higher order only affect the execution sequence when multiple rules run on the same event, but they cannot prevent a rule from executing entirely—order determines sequence, not whether a rule runs. Option D is wrong because scoped applications can access tables within their scope and even global tables if properly configured; the scope does not inherently block access to the table.

Full explanation →

305

MCQeasy

A ServiceNow admin is troubleshooting a data import from an external database via JDBC. The import runs successfully but only loads partial data. Which is the most likely cause?

A.The scheduled import job was interrupted by another job

B.The transform map has a filter that excludes certain records

C.The field mapping is incorrect and some fields are not being populated

D.The JDBC driver has a default row limit that caps the number of records imported

AnswerD

ServiceNow JDBC imports have a default limit of 50,000 rows, which can be adjusted in the datasource configuration.

Why this answer

JDBC drivers often impose a default row limit (e.g., 10,000 rows) to prevent memory overload during data retrieval. When importing from an external database via JDBC, this limit caps the number of records returned, causing only partial data to load even though the import job completes successfully. The admin must explicitly set the fetch size or disable the row limit in the JDBC URL or driver configuration to import all records.

Exam trap

The trap here is that candidates often assume partial data is due to a transform map filter or field mapping error, but the key clue is that the import 'runs successfully' — meaning no errors — which points to a silent cap on row retrieval rather than a configuration or interruption issue.

How to eliminate wrong answers

Option A is wrong because a scheduled import job being interrupted by another job would typically cause the import to fail or produce an error, not complete successfully with partial data. Option B is wrong because a transform map filter that excludes certain records would consistently exclude the same records on every run, not load a partial set of all records; it would also be visible in the transform map configuration. Option C is wrong because incorrect field mapping would result in some fields being empty or null, not in a reduced number of records being imported; the import would still load all rows, but with missing field values.

Full explanation →

306

MCQhard

Refer to the exhibit. A developer created this data policy on the incident table. What will be the result when a user creates or updates an incident where the caller's name is 'VIP'?

A.The condition will always evaluate to true regardless of the caller's name.

B.The short_description field will become mandatory for all incidents.

C.The data policy will cause a client-side error.

D.The condition is invalid because dot-walking is not supported in data policy conditions.

AnswerD

Data policies do not support dot-walking in conditions; the condition is ignored.

Why this answer

Data policy conditions in ServiceNow do not support dot-walking to reference fields like 'caller.name'. The condition must use a direct field on the table (e.g., 'caller') or a scripted condition. Since the condition is invalid, the data policy will not execute, and no field behavior changes will occur.

Exam trap

ServiceNow often tests the misconception that dot-walking is universally supported across all ServiceNow condition builders, when in fact data policy conditions explicitly require direct field references or scripted logic.

How to eliminate wrong answers

Option A is wrong because the condition will not evaluate to true; it will fail to parse due to the unsupported dot-walking syntax, so the policy is effectively ignored. Option B is wrong because the data policy cannot make the short_description field mandatory for all incidents; it only applies when the condition is valid and evaluates to true, which it cannot here. Option C is wrong because data policies are server-side constructs; they do not cause client-side errors—invalid conditions simply prevent the policy from running.

Full explanation →

307

MCQmedium

A ServiceNow developer is designing a portal for end users to submit requests. The requirements state that users should be able to track the status of their requests and receive notifications when the status changes. Which combination of ServiceNow features best meets these requirements?

A.Service Portal and Access Controls (ACLs)

B.Service Portal and Catalog Client Scripts

C.Service Portal and Notifications

D.Service Portal and UI Policies

AnswerC

Service Portal provides the interface; Notifications send status updates.

Why this answer

Service Portal provides the user interface for request submission and tracking, while Notifications (via the Notification and Event Management framework) automatically send email or in-app alerts when a record's status changes. This combination directly fulfills both the tracking and notification requirements without adding unnecessary complexity.

Exam trap

ServiceNow often tests the distinction between client-side features (Client Scripts, UI Policies) and server-side notification mechanisms, leading candidates to mistakenly choose a client-side option for a server-triggered requirement like status change notifications.

How to eliminate wrong answers

Option A is wrong because Access Controls (ACLs) govern data security and permissions, not status tracking or notification delivery. Option B is wrong because Catalog Client Scripts run on the client side to validate or manipulate form data, but they cannot trigger server-side notifications when a status changes. Option D is wrong because UI Policies control field visibility, mandatory status, and read-only behavior on forms, but they do not provide status tracking or notification capabilities.

Full explanation →

308

MCQhard

A developer wants to automatically calculate the number of days an incident has been in the 'On Hold' state. Which approach is most efficient and maintainable?

A.Use a business rule on state update to calculate and store the duration in a custom field.

B.Use a report to calculate the duration on demand.

C.Use a scheduled job to recalculate and update a field daily.

D.Use a calculated field with a formula that references the 'hold_duration' field.

AnswerA

This approach is efficient and updates in real time.

Why this answer

A business rule triggered on state update can calculate the number of days an incident has been in 'On Hold' at the moment the state changes, storing the result in a custom field for persistence and real-time accuracy. Option B (report) calculates duration on demand without storing, so it cannot be used for automated workflows or historical tracking. Option C (scheduled job) runs periodically, introducing delays and inefficiency, and does not update in real time when the state changes.

Option D (calculated field) cannot reference subrecords or perform complex lookups needed to determine the duration an incident has been in a specific state.

Full explanation →

309

MCQmedium

A business rule updates a field on the incident table after submission. However, the updated value is not displayed on the form when the record is opened again. What is the most likely cause?

A.The form is not refreshing after submission.

B.The business rule is set to run asynchronously.

C.A client script (onLoad) is setting the field back to its original value.

D.A UI Policy is hiding the field.

AnswerC

Client scripts execute after the form loads and can override server-set values.

Why this answer

A client script (onLoad) can run after the record is opened and set the field back to its original value, overriding the value updated by the business rule. Option A is incorrect because the form does refresh when the record is opened, so the issue is not a lack of refresh. Option B is incorrect: asynchronous business rules still save their updates to the database; the timing of execution does not affect whether the value persists on the form.

Option D is incorrect because hiding a field via UI Policy does not change its value; the value would still be stored.

Full explanation →

310

Multi-Selectmedium

A developer is creating a new table 'u_incident_custom' to extend the Incident table. Which TWO configurations will ensure that the new table inherits the correct behavior and displays in the application navigator?

Select 2 answers

A.Set 'Application' to the desired scope and check 'Display in application navigator'

B.Create a module pointing to the new table

C.Set 'Label' to 'Incident Custom'

D.Set 'Extends' to 'Incident'

E.Set 'Extends' to 'Task'

AnswersA, D

This ensures the table is scoped correctly and appears in the navigator.

Why this answer

Setting 'Application' to the desired scope ensures the table belongs to the correct application context, and checking 'Display in application navigator' makes the table visible in the application navigator menu. Option D is correct because setting 'Extends' to 'Incident' establishes the inheritance relationship, allowing the new table to inherit all fields, business rules, and behaviors from the Incident table, which itself extends Task.

Exam trap

ServiceNow often tests the distinction between table inheritance (Extends field) and navigator visibility (Display in application navigator), and candidates mistakenly think that setting a label or creating a module alone will achieve inheritance or navigator display.

Full explanation →

311

MCQhard

A UI Macro that displays a custom header is not appearing on the form. The macro is referenced in a UI16 theme. What is the first troubleshooting step?

A.Check the browser's HTML source for the macro's placeholder.

B.Ensure the UI Macro is in the global scope.

C.Verify that all referenced UI Scripts are loaded.

D.Examine the UI Macro record for syntax errors in the HTML or Jelly script.

AnswerD

Syntax errors are the primary reason UI Macros fail to render.

Why this answer

The first troubleshooting step is to examine the UI Macro record for syntax errors in the HTML or Jelly script (Option D). Syntax errors are the most common cause of a macro not rendering. Checking the browser's HTML source (A) is possible but not the first step.

Ensuring the UI Macro is in global scope (B) is less likely the issue, as macros are typically accessible within the theme. Verifying UI Scripts (C) is unrelated because UI Scripts are separate client-side resources, not the macro's own code.

Full explanation →

312

MCQmedium

An organization uses ServiceNow with an external identity provider (IdP) for single sign-on (SSO). Users report that they cannot log in via SSO, but direct username/password login still works. The ServiceNow administrator checks the SAML2 configuration and sees that the 'Validate AuthnResponse Signature' checkbox is enabled and the 'X.509 Certificate' field is filled. What is the most likely cause of the SSO failure?

A.The 'Account lockout after invalid attempts' property is set too low

B.The 'Single Sign-On (SSO)' module is disabled in the ServiceNow application menu

C.The IdP's signing certificate has been rotated, but the new certificate is not uploaded to ServiceNow

D.The 'AuthnRequest Signed' checkbox is not enabled in the SAML2 configuration

AnswerC

If the IdP signs the response with a new certificate, ServiceNow will fail to validate the signature.

Why this answer

The most likely cause is that the IdP's signing certificate has been rotated, but the new certificate is not uploaded to ServiceNow. When 'Validate AuthnResponse Signature' is enabled, ServiceNow uses the uploaded X.509 certificate to verify the SAML assertion signature. If the IdP signs responses with a new certificate that ServiceNow does not have, signature validation fails, blocking SSO login while direct username/password login remains unaffected.

Exam trap

ServiceNow often tests the distinction between request signing and response signing, leading candidates to incorrectly select 'AuthnRequest Signed' (Option D) when the real issue is the IdP's response certificate mismatch.

How to eliminate wrong answers

Option A is wrong because account lockout after invalid attempts would affect both SSO and direct login equally, not just SSO, and the symptom is that direct login still works. Option B is wrong because disabling the 'Single Sign-On (SSO)' module in the application menu would prevent SSO configuration from being accessible, but the SAML2 configuration is already present and the issue is signature validation, not module visibility. Option D is wrong because 'AuthnRequest Signed' controls whether ServiceNow signs the authentication request sent to the IdP; this is not required for validating the IdP's response signature, and the reported symptom points to response validation failure, not request signing.

Full explanation →

313

MCQeasy

A ServiceNow developer is working on a new application that requires a custom table to store project information. The table needs to have fields for project name, start date, end date, and project manager (reference to sys_user). The developer creates the table using the Application Creator and adds the fields. After creating the table, the developer wants to automatically generate a unique project ID in the format 'PROJ-00001' for each new record. The developer considers using a Business Rule with a script or a Default Value with a scripted function. Which approach would be the most efficient and maintainable for generating the project ID?

A.Create an After Insert Business Rule that updates the project ID after the record is saved.

B.Create a Before Insert Business Rule that uses a script to query the current count of records and generate the next ID.

C.Create a calculated field that uses a scripted formula to generate the ID.

D.Create a Default Value for the project ID field using a script that calls a helper function.

AnswerD

Correct: Sets value before insert without extra update, and reusable.

Why this answer

A Default Value script runs before the record is saved, allowing the unique ID to be generated without an extra update. Using a helper function promotes reusability and maintainability, and the script can query the current count of records to generate the next sequential ID in the desired format.

Exam trap

The trap here is that candidates often choose a Business Rule (Before or After Insert) because they think it gives more control, but they overlook that a Default Value script is simpler, more efficient, and avoids the extra update overhead or race condition issues.

How to eliminate wrong answers

Option A is wrong because an After Insert Business Rule would require an additional update to the record after it is already saved, causing unnecessary database operations and potential performance issues. Option B is wrong because a Before Insert Business Rule, while it runs before save, typically does not have access to the final record count reliably due to transaction isolation, and querying the count in a script can lead to race conditions under concurrent inserts. Option C is wrong because a calculated field is read-only and computed on the fly, not stored in the database, so it cannot serve as a persistent unique identifier for the record.

Full explanation →

314

Multi-Selectmedium

A developer is building an application in ServiceNow Studio. Which three of the following are correct practices when using Studio? (Choose three.)

Select 3 answers

A.Utilize the Studio Debugger to test business rules and script includes.

B.Always create application files using the UI instead of importing XML files.

C.Use the Application Explorer to view all application artifacts.

D.Set the application version number manually in the application properties.

E.Avoid using update sets for scoped applications because they are automatically managed.

AnswersA, C, E

Correct: Debugger allows stepping through server-side scripts.

Why this answer

The Studio Debugger allows developers to set breakpoints and step through business rules and script includes in real time, enabling precise testing of server-side logic within the scoped application context. This is essential for validating script behavior without deploying to a separate test instance.

Exam trap

The trap here is that candidates may think manually setting the version number is harmless or necessary for release management, but ServiceNow's automatic versioning is tied to the application's publish lifecycle and update set tracking, making manual edits a source of synchronization errors.

Full explanation →

315

MCQeasy

A developer is creating a service portal widget that shows a list of active incidents. The data should be refreshed every 30 seconds. What is the recommended design pattern?

A.Use a server-side script with a polling model to return data on a timer.

B.Use a third-party library for WebSocket connections.

C.Use a widget option to set the refresh rate and a server-side script to fetch data.

D.Use a client-side JavaScript interval to reload the page.

AnswerC

This combines a configurable option with server-side data retrieval, following best practices.

Why this answer

Using a server-side script with a polling model is the standard approach to periodically fetch data in a widget without overloading the client.

Full explanation →

316

MCQeasy

A developer writes a business rule that runs on after update. The script intends to send an email notification when the priority changes. Which method should be used to compare the previous and current values?

A.current.getDisplayValue('priority') != previous.getDisplayValue('priority')

B.current.priority.changes()

C.current.changes()

D.previous.priority != current.priority

AnswerB

This method returns true exactly when the priority field changes.

Why this answer

The changes() method on a field object returns true if the field changed. Option B is correct. Option A checks if any field changed.

Option C uses direct comparison but is not a method. Option D uses getDisplayValue which compares labels, not values.

Full explanation →

317

MCQmedium

Refer to the exhibit. What is the purpose of this transform script?

A.To ignore records with empty department.

B.To map the department field only if source department is not empty.

C.To set a default value for the department field.

D.To map all fields from source to target.

AnswerB

The if condition ensures mapping only when source has a value.

Why this answer

The transform script maps the 'department' field only if the source field 'u_department' is not empty, as indicated by the conditional logic. Option A is incorrect because the script does not ignore records; it only skips mapping for empty departments. Option C is incorrect because no default value is set; the field is simply not mapped if empty.

Option D is incorrect because only the department field is mapped conditionally, not all fields.

Full explanation →

318

MCQhard

A developer reports that an after business rule on the Change Request table is running twice for each update. The business rule is not scheduled or async. Which is the most likely cause?

A.The business rule is set to run 'On Update' and also 'On Insert'

B.The business rule order is too high

C.The business rule script updates the same record, causing a loop

D.The business rule exists in two different scoped applications

AnswerC

Correct; the after business rule triggers an update that re-executes the rule, resulting in double execution.

Why this answer

An after business rule that updates the same record it triggered on will cause the business rule to fire again on the subsequent update, creating a recursive loop. Since the rule is not scheduled or async, each update triggers the rule synchronously, and if the script performs a `current.update()` or similar operation on the same table, it re-fires the same business rule, leading to duplicate execution.

Exam trap

The trap here is that candidates often confuse a business rule running twice due to a loop with other causes like incorrect event conditions or scope duplication, but the core issue is the recursive update within the same rule's script.

How to eliminate wrong answers

Option A is wrong because a business rule set to run 'On Update' and 'On Insert' would fire once on insert and once on update, not twice on the same update operation. Option B is wrong because the order value only determines the sequence of execution among multiple business rules on the same table and event, not the number of times a single rule runs. Option D is wrong because a business rule existing in two different scoped applications would cause one of them to be ignored (the one in the higher-priority scope or the one that is not active), not duplicate execution on the same record update.

Full explanation →

319

MCQmedium

A Service Portal widget displays a list of catalog items. Each catalog item should link to a record producer that opens in a modal dialog. Which approach should the developer use to open the modal?

A.Use $scope.$broadcast to trigger a modal event

B.Use spModal.open with the record producer sys_id

C.Use $uibModal.open to create a modal with a custom template

D.Use window.open to open the record producer URL

AnswerC

$uibModal is the Angular UI Bootstrap service for modals.

Why this answer

Service Portal widgets use AngularJS, and the standard way to open a modal with a custom template (such as a record producer form) is via `$uibModal.open`. This method allows the developer to specify a controller, template, and resolve data, giving full control over the modal's behavior and content. Record producers are typically rendered inside a custom template, not directly via a sys_id parameter.

Exam trap

ServiceNow often tests the distinction between Service Portal-specific utilities (`spModal`) and general AngularJS UI Bootstrap (`$uibModal`), leading candidates to incorrectly choose `spModal.open` for complex modals like record producers.

How to eliminate wrong answers

Option A is wrong because `$scope.$broadcast` is used to send events down the scope hierarchy, not to open modals; it would require a listener to handle the event and manually create a modal, which is an indirect and non-standard approach. Option B is wrong because `spModal.open` is a Service Portal utility for simple confirmations or alerts, not for opening record producers; it does not accept a record producer sys_id to render a form. Option D is wrong because `window.open` opens a new browser tab or window, not a modal dialog within the Service Portal, and it would break the single-page application experience.

Full explanation →

320

Multi-Selecthard

An organization is planning to import a large dataset into ServiceNow using import sets. According to best practices, which TWO actions should the developer take to optimize performance? (Choose two.)

Select 2 answers

A.Disable business rules and ACLs during import.

B.Increase the import set table row limit.

C.Enable 'Create multiple' for transform maps.

D.Use a single transform map for all records.

E.Use scheduled imports instead of manual imports.

AnswersA, E

This reduces overhead and speeds up import significantly.

Why this answer

Scheduling imports during off-peak hours reduces load on the system. Disabling business rules and ACLs during import speeds up processing by avoiding unnecessary checks.

Full explanation →

321

MCQhard

A ServiceNow developer is building a custom service portal widget that displays a list of open incidents for the current user. The widget includes a button to reassign an incident to a selected group. The developer writes a client controller function that calls $http.post to a scripted REST API endpoint. However, when the button is clicked in production, the console shows 'unexpected token <'. The developer confirms the endpoint does not exist. What is the best course of action?

A.Change the button to a direct link to a different page.

B.Create a script include with the reassign logic, and call it from the widget server-side script using a client callable action.

C.Move the entire reassign logic to a client-side script using GlideRecord via Ajax.

D.Use a custom UI macro instead of a widget.

AnswerB

This uses the proper ServiceNow architecture: server-side logic via Script Include, exposed via server script, and invoked via client callable.

Why this answer

Using a script include with a server-side script and widget server-side script is the recommended pattern for server-side logic. It avoids direct REST calls and follows ServiceNow best practices.

Full explanation →

322

MCQhard

Refer to the exhibit. A Business Rule in the same scope calls this script include using 'var total = new MyUtils().getTotal("invoice", "state=paid");' but gets '0' even though there are records. What is the most likely cause?

A.The getTotal method is not properly defined.

B.The 'amount' field is not numeric in the invoice table.

C.The GlideAggregate query syntax is incorrect.

D.The script include is not accessible from the Business Rule's scope.

AnswerB

Non-numeric field causes SUM to return null.

Why this answer

The Business Rule calls `getTotal` which uses `GlideAggregate` to sum the `amount` field. If the `amount` field is not numeric (e.g., it is a string or another non-numeric type), `GlideAggregate.addAggregate('SUM', 'amount')` will return `0` because it cannot perform a numeric aggregation on non-numeric data. This matches option B.

Exam trap

ServiceNow often tests the misconception that a GlideAggregate query syntax error is the cause, when the real issue is a non-numeric field type that prevents aggregation from returning a valid sum.

How to eliminate wrong answers

Option A is wrong because the script include is called successfully (no error), so the method is properly defined. Option C is wrong because the GlideAggregate query syntax is correct: `addQuery('state', 'paid')` and `addAggregate('SUM', 'amount')` are standard methods. Option D is wrong because the Business Rule and script include are in the same scope, so accessibility is not an issue.

Full explanation →

323

MCQeasy

Which of the following is a best practice when creating REST API endpoints?

A.Use GET methods for data modification.

B.Use versioning in the API path.

C.Pass sensitive data in URL parameters.

D.Return all data without pagination.

AnswerB

Correct: Versioning allows backward compatibility.

Why this answer

Versioning the API path (e.g., /api/now/v1/incident) is a best practice to manage changes without breaking existing consumers.

Full explanation →

324

MCQeasy

Which scripting environment should be used to write a Business Rule that runs on schedule?

A.Business Rule

B.Events

C.Script Include

D.Scheduled Job

AnswerD

Scheduled Jobs run at defined intervals.

Why this answer

A Scheduled Job is the correct scripting environment for running a Business Rule on a schedule because Business Rules in ServiceNow are event-driven and execute only when a record is inserted, updated, deleted, or queried. To run logic at a specific time or interval, you must use a Scheduled Job, which leverages the system's job scheduler (based on Quartz) to execute a script at defined intervals or cron expressions.

Exam trap

The trap here is that candidates confuse the 'Business Rule' name with the ability to run on a schedule, but ServiceNow explicitly separates event-driven logic (Business Rules) from time-based logic (Scheduled Jobs), and the exam tests this distinction.

How to eliminate wrong answers

Option A is wrong because a Business Rule runs only in response to database operations (insert, update, delete, query) on a table, not on a time-based schedule. Option B is wrong because Events are used to trigger notifications, scripts, or other actions in response to a condition, but they themselves do not run on a schedule; they are fired by other processes. Option C is wrong because a Script Include is a reusable server-side script library that must be called from another script (e.g., a Business Rule or Scheduled Job) and cannot run autonomously on a schedule.

Full explanation →

325

Multi-Selectmedium

When creating a custom table to extend an existing table, which TWO considerations should be evaluated to ensure optimal performance and maintainability? (Choose two.)

Select 2 answers

A.The table must have a unique name starting with 'u_'

B.The table should be created in the global scope to ensure universal access

C.The table must have a reference field back to the parent table

D.The number of records in the parent table may impact query performance when retrieving child records

E.Adding too many fields to the extended table can degrade performance and increase complexity

AnswersD, E

When extending, queries often include parent table records, which can slow down if the parent table is large.

Why this answer

Options D and E are correct. When extending a table, the number of records in the parent table can impact query performance when retrieving child records because child tables inherit the parent table's data, and queries may need to scan the parent table as well. Adding too many fields to an extended table can degrade performance (more data to store and process) and increase complexity (harder to maintain relationships and ACLs).

Option A is incorrect because while ServiceNow suggests a naming convention with 'u_' for custom tables, it is not a strict requirement for performance or maintainability. Option B is incorrect because the table should be created in the same scope as the application it belongs to, not necessarily global scope. Option C is incorrect because a reference field back to the parent table is not required; the table extension itself establishes the relationship via inheritance.

Full explanation →

326

MCQhard

A developer creates a script include with client-callable true. The script include is used in a client script to validate a field. However, when the client script runs, it throws an error that GlideAjax is not defined. What is the most likely issue?

A.The script include is not marked as 'Client-callable'.

B.The client script is running in a UI policy instead of a client script.

C.The script include is a global scope but the client script is in a scoped application.

D.The client script is not using the correct GlideAjax syntax.

AnswerB

Correct. UI policies do not support GlideAjax, causing 'GlideAjax is not defined' if the script is placed there instead of in a client script.

Why this answer

The error 'GlideAjax is not defined' occurs when GlideAjax is used in a context that does not support it, such as a UI policy script. UI policies run on the server side and do not have access to client-side APIs like GlideAjax. Even though the script include is marked client-callable, the client script itself must be a true client script (e.g., onChange, onLoad) to use GlideAjax.

Option B correctly identifies this scenario: the developer may have accidentally placed the script in a UI policy instead of a client script.

Exam trap

ServiceNow often tests the misconception that client-callable script includes in the global scope are accessible from any client script, ignoring that client scripts in scoped applications cannot directly use GlideAjax from the global scope.

How to eliminate wrong answers

Option A is wrong because the script include is already marked as client-callable (as stated in the question), so this is not the issue. Option B is wrong because UI Policies also run client-side JavaScript and can use GlideAjax; the error is not specific to the execution context of a UI Policy vs. a client script. Option D is wrong because the error 'GlideAjax is not defined' is a JavaScript reference error indicating the GlideAjax class itself is not available, not a syntax error in how it is used.

Full explanation →

327

MCQeasy

A developer needs to update a large number of records in the 'incident' table based on a specific condition. Which approach should be used to minimize performance impact?

A.Use GlideRecord with setWorkflow(false) and setEngine(false) to update records in a loop.

B.Use GlideAggregate to perform the update.

C.Use an export set to update records in bulk.

D.Use the updateMultiple method on a GlideRecord object.

AnswerA

Using GlideRecord with setWorkflow(false) and setEngine(false) prevents business rules and workflow execution, reducing overhead.

Why this answer

A is correct because using GlideRecord with setWorkflow(false) and setEngine(false) prevents unnecessary business rules and workflow execution, reducing performance impact. B is incorrect because GlideAggregate is used for aggregation and statistics, not for updating records. C is incorrect because an export set is designed for data export/import, not for bulk updates within the platform.

D is incorrect because updateMultiple does perform bulk updates but still triggers business rules if not disabled, and it does not provide the same level of control as GlideRecord with disabled workflows.

Full explanation →

328

MCQmedium

Refer to the exhibit. After creating this database view, the view contains fewer records than the sum of records in incident and problem tables. What is the most likely cause?

A.The view must include the 'active' field from both tables

B.UNION should be UNION ALL to retain duplicate rows

C.A database view cannot combine records from incident and problem tables

D.The SELECT statement should include DISTINCT

AnswerB

UNION deduplicates rows, reducing the count if overlaps exist.

Why this answer

The UNION operator by default removes duplicate rows. If there are overlapping records between the incident and problem tables (e.g., same sys_id, number, or short_description), UNION eliminates them, resulting in fewer records than the sum of the two tables. Using UNION ALL would retain all rows, including duplicates.

Option A is incorrect because the 'active' field is not required for the view to include all records. Option C is false because database views can combine records from multiple tables. Option D is incorrect because DISTINCT is already implied by UNION and would further reduce rows, not increase them.

Full explanation →

329

MCQhard

A ServiceNow instance has a custom table 'u_staff' extended from the User table. A business rule on the 'User' table updates the 'Active' field. When updating a user record, the business rule does not fire for records in 'u_staff'. What is the most likely reason?

A.The user does not have permission to run business rules on the 'u_staff' table

B.Business rules on the User table do not fire on child table records

C.The business rule has a condition that only allows running on User table records

D.The business rule ordering is set too low and is being skipped

AnswerB

By default, business rules on a base table do not extend to child tables. You must set the 'Inherited' checkbox on the business rule to fire on child records.

Why this answer

Business rules on a parent table (User) do not automatically fire on child table records (u_staff) unless the business rule is configured to run on descendant tables. By default, business rules operate only on the table they are defined on. Option A is incorrect because permission is not the issue; the rule simply isn't triggered.

Option C is incorrect because even without a specific condition, the rule won't fire on child tables. Option D is incorrect because ordering affects execution order, not whether the rule fires at all.

Full explanation →

330

MCQhard

A company uses ServiceNow to manage IT assets. An integration sends asset data from an external CMDB to ServiceNow via REST API. The external system sends a payload that includes the asset's serial number, location, and status. The developer has created a Scripted REST API to receive this data. However, when testing, the external system receives an HTTP 500 error. The developer inspects the script log and sees the error: 'java.lang.NullPointerException' at line 10 of the script. The script uses the GlideRecord API to query for an existing asset by serial number. The relevant code is: var gr = new GlideRecord('alm_asset'); gr.get('serial_number', request.body.serial); What is the most likely cause of the NullPointerException?

A.The 'serial_number' field in the 'alm_asset' table does not exist or is misspelled

B.The GlideRecord.get() method is incorrectly used; it should be gr.get('serial_number') without the value

C.The request body is not being parsed; 'request.body' is null because the content type is not set to JSON or the API is not expecting a body

D.The external system is sending the serial number as part of the URL instead of the request body

AnswerC

If the API does not parse the body, request.body remains null, causing a NullPointerException when accessing .serial.

Why this answer

The NullPointerException occurs when trying to access a property of a null object. In this case, `request.body` is null, meaning the request body was not parsed into a JavaScript object. This typically happens when the Content-Type header is not set to `application/json` or the Scripted REST API endpoint is not configured to expect a request body, so `request.body.serial` evaluates to `null.serial`, causing the exception.

Exam trap

The trap here is that candidates often assume the NullPointerException is due to a field name typo or incorrect GlideRecord usage, but the real issue is that `request.body` is null because the request body was not parsed, which is a subtle but critical detail about REST API request handling in ServiceNow.

How to eliminate wrong answers

Option A is wrong because a misspelled or non-existent field name would throw a ScriptException or return an empty GlideRecord, not a NullPointerException at line 10. Option B is wrong because `gr.get('serial_number', value)` is the correct syntax for querying by field and value; using `gr.get('serial_number')` without a value would query by sys_id, not by serial number. Option D is wrong because even if the serial number were sent in the URL, the error is specifically about `request.body` being null, not about missing URL parameters.

Full explanation →

331

MCQeasy

A user reports that a field 'Cost Center' is not visible on a form, but the UI Policy condition to show it is met. What is the first step in troubleshooting?

A.Check the form layout to ensure the field is present on the form.

B.Check the client script that may be hiding the field.

C.Check the ACLs for the 'Cost Center' field.

D.Check the role requirements for the field.

AnswerA

If the field is not on the form, no UI policy can make it appear.

Why this answer

Checking the form layout ensures the field is actually placed on the form, as UI policies can only control visibility if the field exists on the form.

Full explanation →

332

MCQhard

A developer implemented an ACL to restrict read access on the 'incident' table. The condition script checks if the user is a member of the 'incident_manager' group. However, users who are not in the group are still able to see incidents. What is the most likely reason?

A.There is another ACL with a lower order that grants read access to all users, and the evaluation never reaches the scripted ACL.

B.The ACL is cached and users need to log out and back in for changes to take effect.

C.The condition script returns 'true' for users in the group but does not return 'false' for others, so the ACL defaults to 'no decision' and access is allowed.

D.The ACL is set to 'Inactive' so it does not apply, leaving access open.

AnswerA

ACLs are evaluated in ascending order; the first matching ACL is applied. A lower-order granting ACL can override a higher-order restrictive one.

Why this answer

ACLs in ServiceNow are evaluated in order of their 'Order' field (lower numbers first). If a lower-order ACL grants read access to all users, the evaluation stops at that ACL and never reaches the scripted ACL that restricts access to the 'incident_manager' group. This is the most common reason for an ACL appearing to not work — a broader, higher-priority ACL is allowing access before the restrictive one is evaluated.

Exam trap

The trap here is that candidates may overlook the ACL ordering (i.e., the 'Order' field) and assume that a restrictive ACL placed after a broader one will override it. In ServiceNow, ACLs are evaluated in ascending order of their 'Order' value, and once an ACL grants access, the evaluation stops. Therefore, a lower-order ACL that grants read access to all users will allow access before a higher-order restrictive ACL is even reached.

How to eliminate wrong answers

Option B is wrong because ACL changes in ServiceNow take effect immediately; there is no caching mechanism that requires a logout/login. Option C is wrong because if the condition script does not return 'false' for non-members, the ACL returns 'no decision', which means the system continues evaluating the next ACL in order — it does not default to allowing access. Option D is wrong because if the ACL were set to 'Inactive', it would be completely ignored, but the question states the developer implemented the ACL, implying it is active; even if inactive, the symptom would be that no restriction applies, but the most likely reason among the choices is the order issue.

Full explanation →

333

Multi-Selecteasy

A new custom table is being created in ServiceNow. Which two attributes must be defined during table creation? (Choose two.)

Select 2 answers

A.Table label

B.Access control rules

C.Extensible checkbox

D.Application scope

E.Table name

AnswersA, E

Required: The display label for the table must be specified.

Why this answer

The table label (A) is the human-readable name displayed in the ServiceNow UI, such as in lists and forms, and is required for user interaction. The table name (E) is the system name used internally in the database (e.g., 'u_custom_table'), and it must be unique within the instance. Both are mandatory fields when creating a new custom table in ServiceNow.

Exam trap

The trap here is that candidates often confuse 'required during creation' with 'commonly configured later,' leading them to select access control rules or the extensible checkbox as mandatory attributes.

Full explanation →

334

MCQmedium

A developer encounters the following error when a scheduled job executes. The job queries the 'u_my_table' table. What is the most likely cause?

A.The field u_extra_field was recently deleted from the table.

B.The table name is misspelled in the script.

C.The script include has a syntax error.

D.The field u_extra_field exists but is not indexed.

AnswerA

Correct: The error says 'Invalid field name', meaning the field is not found in the table. Deletion is the most likely cause.

Why this answer

The error occurs because the scheduled job references the field 'u_extra_field' in its query against the 'u_my_table' table. When that field is deleted from the table definition, any script or job that attempts to read or write to that field will fail with a 'column not found' or similar database error. This is the most direct cause among the options, as the job was previously working and the error appeared after a schema change.

Exam trap

ServiceNow often tests the distinction between schema-related errors (deleted fields) and other error types (syntax, missing indexes, misspellings) to see if candidates understand that a field deletion directly breaks queries referencing that field, while other options cause different symptoms or no error at all.

How to eliminate wrong answers

Option B is wrong because a misspelled table name would cause a 'table not found' error, not a field-related error, and the error message would reference the table name, not a field. Option C is wrong because a syntax error in a script include would typically produce a compile-time or runtime error unrelated to a specific field in a table query. Option D is wrong because a missing index on a field does not cause an error when querying; it only impacts performance, and the job would still execute successfully.

Full explanation →

335

MCQeasy

Which record type should be used to customize the look and feel of the UI16 interface?

A.UI Script (sys_ui_script)

B.Portal Theme (sp_theme)

C.UI Theme (sys_ui_theme)

D.Branding (sys_brand)

AnswerC

UI Themes define the styling for UI16.

Why this answer

UI Theme (sys_ui_theme). In ServiceNow, the UI16 interface's look and feel is customized using UI Themes, which are stored in the 'sys_ui_theme' table. Option A (UI Script) is incorrect because UI Scripts are used for client-side JavaScript functions, not for theming.

Option B (Portal Theme) is meant for Service Portal configurations, not the UI16 interface. Option D (Branding) handles logos, colors, and fonts but does not provide the full theme customization capabilities of UI Themes.

Full explanation →

336

Drag & Dropmedium

Drag and drop the steps to configure a Business Rule in ServiceNow into the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

Why this order

The standard workflow: navigate to Business Rules, create new, specify table and name, set conditions, then script and submit.

Full explanation →

337

MCQeasy

A UI Policy is used to make a field mandatory when another field has a specific value. The policy is not triggering. What is the first step to troubleshoot?

A.Verify that a script include used in the condition is accessible

B.Ensure the field has a 'Mandatory' attribute on the dictionary

C.Check if the 'Mandatory' ACL on the field prevents modification

D.Review the UI Policy conditions and the order of policies on the form

AnswerD

UI Policies are evaluated in order; a later policy may override the mandatory setting.

Why this answer

When a UI Policy is not triggering, the first step is to review the UI Policy conditions and the order of policies on the form. This ensures the condition is correctly set and not overridden by other policies. Option A is incorrect because script includes are not typically used in UI Policy conditions; UI Policies use simple conditions or scripts that can access script includes, but verifying accessibility is not the first step.

Option B is incorrect because the 'Mandatory' attribute on the dictionary is a different configuration; UI Policy can make a field mandatory irrespective of dictionary attributes. Option C is incorrect because ACLs control access, not mandatory behavior; they do not prevent UI Policy from making a field mandatory.

Full explanation →

338

MCQmedium

A Script Include is defined as 'Scoped' and has 'Accessible from' set to 'All applications'. It contains a function that uses 'gs.getUser()'. When the Script Include is called from a Business Rule in a different application scope, what is the result?

A.The function runs successfully and gs.getUser() returns the current user from the caller's session.

B.An error occurs because scoped Script Includes cannot be called from other applications.

C.The function runs but gs.getUser() returns the user from the Script Include's application scope, not the caller.

D.The function runs but returns null because gs is not available in scoped applications.

AnswerA

Scoped Script Includes with 'All applications' access can be called from any scope, and gs APIs work globally.

Why this answer

A Script Include defined as 'Scoped' with 'Accessible from' set to 'All applications' is explicitly made available to other application scopes. When called from a Business Rule in a different scope, the function executes in the context of the caller's session, so `gs.getUser()` returns the current user from the caller's session, not from the Script Include's own scope. This behavior is governed by the scoping rules that allow cross-application access when the property is set accordingly.

Exam trap

The trap here is that candidates often confuse 'Accessible from' with runtime context, incorrectly assuming that a scoped Script Include runs in its own application scope and thus returns a different user, when in fact the session context is always preserved.

How to eliminate wrong answers

Option B is wrong because scoped Script Includes can be called from other applications if the 'Accessible from' property is set to 'All applications', which is the case here. Option C is wrong because `gs.getUser()` always returns the user from the caller's session, not from the Script Include's application scope; the scope of the Script Include does not affect the session context. Option D is wrong because `gs` is fully available in scoped applications; it is a global object provided by the platform and is not restricted by scope.

Full explanation →

339

MCQmedium

A ServiceNow instance has a custom application for managing IT assets. The application uses a custom table 'u_asset' with fields: u_asset_tag (string), u_model (string), u_assignee (reference to sys_user), u_status (choice: In Use, In Stock, Retired). The application requires that when an asset is retired, the assignee field must be cleared. The developer created a Business Rule on the 'u_asset' table that runs before update. The script checks if the status changes to 'Retired' and sets the assignee to empty. However, the assignee is not being cleared when the status is changed to 'Retired'. The Business Rule is active and runs before update. What is the most likely cause?

A.The script sets the field using 'current.u_assignee = null;' instead of 'current.setValue("u_assignee", "");'.

B.The Business Rule is set to run after the record is saved, so changes are overwritten.

C.The condition 'current.u_status.changesTo("Retired")' is incorrect.

D.The Business Rule runs after update instead of before update.

AnswerA

Setting a reference field to null directly may not work; setValue should be used.

Why this answer

In ServiceNow Business Rules, setting a field to null using direct assignment (e.g., current.u_assignee = null) does not trigger the platform's update logic; the change is not persisted to the database. The correct method is to use current.setValue('u_assignee', '') which properly marks the field for update and clears the reference.

Exam trap

The trap here is that candidates often assume direct assignment works for all field types, but ServiceNow requires setValue() for proper update tracking, especially when clearing reference fields.

How to eliminate wrong answers

Option B is wrong because the Business Rule is explicitly set to run 'before update', not after, so the timing is correct. Option C is wrong because current.u_status.changesTo('Retired') is a valid and commonly used condition that correctly detects a change to the specified choice value. Option D is wrong because the question states the Business Rule runs before update, and the issue is not about the run order but about how the field value is assigned.

Full explanation →

340

Multi-Selecthard

A developer needs to create a new table that will store confidential employee feedback. The table must have the following characteristics: (1) Only authorized HR users can read the records. (2) The table should use the 'task' model to leverage assignment and state fields. (3) The table should be accessible via web services for integration. Which TWO actions are required to meet these requirements?

Select 2 answers

A.Set the 'table' access policy to 'Internal'

B.Extend the 'incident' table instead of 'task'

C.Enable the 'Allow web service access' property on the table

D.Extend the 'task' table

E.Create ACLs on the table to restrict read access to HR users

AnswersD, E

Task provides assignment and state fields.

Why this answer

Extending the 'task' table allows the new table to inherit the assignment and state fields required by the 'task' model. This is the standard approach in ServiceNow for creating tables that leverage task-related functionality, such as assignments and workflow states.

Exam trap

The trap here is that candidates often confuse the 'Allow web service access' property with a security control, when in fact it only enables the endpoint and does not restrict access; proper ACLs are required to enforce read restrictions.

Full explanation →

341

Multi-Selectmedium

Which TWO statements about ServiceNow UI Policies are true?

Select 2 answers

A.UI Policies can enforce data integrity at the database level

B.UI Policies can set fields as mandatory

C.UI Policies cannot be used on catalog items

D.UI Policies can have multiple script actions

E.UI Policies run on the server side only

AnswersB, D

True; UI Policy actions include setting mandatory, visible, etc.

Why this answer

UI Policies are client-side scripts that run on the browser to dynamically control form behavior, such as making fields mandatory, visible, or read-only based on conditions. Option B is correct because UI Policies can set the 'mandatory' attribute on a field, forcing users to provide a value before submitting the record.

Exam trap

The trap here is that candidates often confuse UI Policies with Business Rules, assuming UI Policies run server-side or can enforce database-level integrity, when in fact they are purely client-side and only affect the user interface.

Full explanation →

342

MCQmedium

A developer is designing a REST message to send data from ServiceNow to an external system. The external system expects a new resource to be created at a specific endpoint. Which HTTP method should be used?

A.PUT

B.PATCH

C.GET

D.POST

AnswerD

POST is the standard method for creating new resources.

Why this answer

The correct HTTP method is POST (option D). POST is used to create new resources on the server. Option A (PUT) is typically used to update or replace an existing resource, not create a new one at a specific endpoint.

Option B (PATCH) is used for partial updates to an existing resource. Option C (GET) is used to retrieve data, not create new resources.

Full explanation →

343

MCQmedium

A custom table 'u_incident' has a 'priority' field that should be set to 1 when the 'category' is 'Critical', otherwise 3. Which is the most efficient way to implement this default?

A.Create a Business Rule on 'Before Insert' that sets the priority

B.Create a Client Script that runs onLoad and sets priority

C.Use a UI Policy to set priority based on category

D.Define a default value script in the dictionary for the priority field

AnswerD

Executes at database level with no extra rule overhead.

Why this answer

The most efficient way is to define a default value script in the dictionary for the 'priority' field. This script runs server-side during record insertion and sets the priority based on the category without additional database operations. Option A (Business Rule) works but adds overhead compared to a dictionary default.

Option B (Client Script) is client-side and can be bypassed or not execute. Option C (UI Policy) only affects client-side behavior and does not set field values on the server.

Full explanation →

344

Multi-Selecteasy

Which TWO of the following are valid ways to create a UI Action?

Select 2 answers

A.Duplicate an existing UI Action from the list view.

B.Create a new UI Action record from the UI Actions module.

C.Write a Script Include and configure it as a UI Action.

D.Create a UI Action from the Form Design interface.

E.Create a UI Action from the Business Rules module.

AnswersA, B

Duplicating is a valid method to create a new UI Action.

Why this answer

Options A and B are correct. UI Actions can be created by duplicating an existing UI Action from the list view (Option A) or by creating a new UI Action record directly from the UI Actions module (Option B). Option C is wrong because Script Includes are separate server-side scripts and cannot be configured directly as UI Actions (they might be used in UI Action scripts, but not a direct creation method).

Option D is wrong because the Form Design interface is used for layout customization, not for creating UI Actions. Option E is wrong because the Business Rules module is for business rules, a different record type.

Full explanation →

345

MCQhard

A company uses Service Portal for employee self-service. One widget displays a list of open requests from the sc_request table. The widget uses a server script that queries all records without a filter. As the request table grows, users experience slow loading times. The widget configuration allows client-side filtering but not server-side pagination. The developer must improve performance without changing the user experience. What should the developer do?

A.Increase the server timeout value to allow more time for the query to complete.

B.Implement pagination in the server script and modify the widget to load data in chunks.

C.Add a client-side filter to the widget to display only a subset of records.

D.Use a UI Policy to hide the widget for users with many requests.

AnswerB

Pagination reduces the amount of data sent per request, improving initial load time.

Why this answer

Implementing server-side pagination reduces the amount of data retrieved from the database in a single query, which directly addresses the performance bottleneck caused by loading all records from the sc_request table. By modifying the server script to return only a subset of records (e.g., 25 per page) and updating the widget to request subsequent pages as the user scrolls or clicks, the developer improves load times without altering the user experience. This approach leverages ServiceNow's GlideRecord query efficiency and avoids the overhead of transferring and rendering large datasets on the client.

Exam trap

The trap here is that candidates often confuse client-side filtering with server-side optimization, assuming that filtering on the client reduces server load, when in fact the entire dataset must still be fetched from the database.

How to eliminate wrong answers

Option A is wrong because increasing the server timeout does not reduce the query execution time or the amount of data transferred; it only masks the symptom by allowing more time for the slow operation to complete, which does not solve the underlying performance issue. Option C is wrong because adding a client-side filter still requires the server to fetch all records from the sc_request table before filtering on the client, so the database query and data transfer remain unchanged, and performance does not improve. Option D is wrong because using a UI Policy to hide the widget for users with many requests alters the user experience by denying access to the widget, which violates the requirement to not change the user experience.

Full explanation →

346

Multi-Selecteasy

Which TWO are valid data source types for Import Sets in ServiceNow? (Choose two.)

Select 2 answers

A.JDBC

B.REST

C.LDAP

D.SNMP

E.Syslog

AnswersA, B

JDBC allows importing from external databases.

Why this answer

The correct answers are A and B. REST and JDBC are both valid data source types for Import Sets. LDAP, SNMP, and Syslog are not supported as data source types.

Full explanation →

347

Multi-Selecteasy

Which TWO are best practices when implementing data integrations using ServiceNow import sets?

Select 2 answers

A.Schedule the import to run during off-peak hours

B.Use REST API instead of import sets for better performance

C.Use update sets to manage import set configurations

D.Use coalesque in the transform map to avoid duplicates

E.Always use a staging table for all data sources

AnswersA, D

Scheduling minimizes impact on system performance.

Why this answer

Options A and D are correct. A: Scheduling imports during off-peak hours minimizes impact on system performance and user experience. D: Using coalesce in the transform map on a unique field prevents duplicate records by matching existing records based on that field.

B is incorrect because REST API is an alternative integration method, not a performance improvement over import sets. C is incorrect because update sets are used to move configurations between instances, not to manage import set configurations. E is incorrect because while staging tables are commonly used, they are not always required for all data sources.

Full explanation →

348

MCQeasy

You are a ServiceNow developer at a company that manages IT assets. You are asked to create a new table called 'u_software_license' to track software licenses. The table must have fields for license name, vendor, purchase date, expiration date, cost, and number of seats. Additionally, the table must be accessible from the 'Software' module in the application navigator. You have created the table with the appropriate fields. However, after creating the table, it does not appear in the 'Software' module. You verify that the table is set to extend 'Task' and that the application scope is correct. What is the most likely reason the table does not appear in the module?

A.The table name 'u_software_license' is not compatible with the Software module.

B.The 'Display in application navigator' checkbox is not checked on the table configuration.

C.A module has not been created to reference the new table.

D.The table extends 'Task' instead of 'Software', so it cannot appear in the Software module.

AnswerC

Correct. A module record referencing the table must be created to display the table under the 'Software' module.

Why this answer

The table does not appear in the 'Software' module because no module record exists that maps the table to that module. To display a table under a specific module in the application navigator, you must create a module record that references the table. The 'Display in application navigator' checkbox only adds the table as a top-level entry, not under a module.

Since the user verified the table extends Task and the application scope is correct, the missing step is creating a module record.

Exam trap

Candidates often confuse the 'Display in application navigator' checkbox with module visibility, thinking it controls placement under a specific module, when in fact a module record is required for that.

How to eliminate wrong answers

Option A is wrong because table names like 'u_software_license' are fully compatible with modules; the name has no bearing on navigator visibility. Option C is correct, not wrong, but the question asks for the most likely reason the table does not appear, and the correct answer is that a module has not been created to reference the new table. Option D is wrong because extending 'Task' does not prevent a table from appearing in the Software module; modules are independent of table inheritance and can reference any table regardless of its parent.

Full explanation →

349

MCQhard

A company is integrating ServiceNow with an external system using a custom SOAP web service. The external system requires WS-Security with a username token and a timestamp. How should the developer configure this?

A.Use a RESTMessageV2 with Basic Authentication.

B.Add the username and password to the SOAP message's HTTP headers.

C.Configure the WS-Security tab under the SOAP Message record with UsernameToken and timestamp.

D.Set the SOAP action header to include the token.

AnswerC

The SOAP Message record has dedicated WS-Security settings.

Why this answer

ServiceNow's SOAP Message record includes a dedicated WS-Security tab where you can configure UsernameToken and timestamp elements to meet WS-Security requirements. This allows the platform to generate the proper SOAP envelope headers with the security token and timestamp, which the external system expects for authentication and message freshness validation.

Exam trap

The trap here is that candidates confuse HTTP-level authentication (like Basic Auth in headers) with WS-Security, which requires security tokens to be embedded inside the SOAP envelope itself, not in transport-level headers.

How to eliminate wrong answers

Option A is wrong because RESTMessageV2 is used for RESTful services, not SOAP, and Basic Authentication does not implement WS-Security standards. Option B is wrong because adding credentials to HTTP headers is not part of the WS-Security specification; WS-Security requires the token to be embedded within the SOAP envelope's <wsse:Security> header, not in HTTP headers. Option D is wrong because the SOAP action header is used to specify the operation being invoked (e.g., via SOAPAction), not to carry security tokens; tokens must be placed in the WS-Security header of the SOAP message.

Full explanation →

350

Multi-Selecteasy

Which TWO are benefits of using a Service Portal widget over a UI Page?

Select 2 answers

A.Widgets automatically handle user authentication.

B.Widgets can be easily reused across multiple portals.

C.Widgets provide built-in accessibility features.

D.Widgets are faster because they use synchronous server calls.

E.Widgets support AngularJS data binding.

AnswersB, E

Widgets are designed for reusability and can be added to any portal.

Why this answer

Service Portal widgets are designed as reusable components that can be shared across multiple portals without duplication. Unlike UI Pages, which are page-specific and must be copied or recreated for each portal, widgets can be configured with options and instances, making them modular and maintainable. Option E is correct because Service Portal widgets natively support AngularJS, enabling two-way data binding between the client-side controller and the HTML template, which simplifies dynamic UI updates without manual DOM manipulation.

Exam trap

ServiceNow often tests the misconception that UI Pages are obsolete or that widgets are inherently faster, but the real differentiator is reusability and AngularJS data binding, not performance or built-in features.

Full explanation →

351

MCQhard

This ACL is configured to control read access on the 'incident' table. Under what condition will a user be allowed to read an incident record?

A.If the user is from the company specified, regardless of the assigned_to field.

B.If the user is from the company specified in the property and the incident is assigned to the user.

C.If the user is from the company specified and the incident is assigned to the user's manager.

D.If the user's manager is from the company specified and the incident is assigned to the user.

AnswerC

Both conditions: user's company matches property, and incident assigned to user's manager.

Why this answer

The ACL condition checks that the user's company matches the company specified in the property, and the incident record's assigned_to field equals the user's manager. This is a common pattern in ServiceNow where read access is granted based on a relationship (manager) rather than direct assignment, ensuring that managers can view incidents assigned to their direct reports.

Exam trap

The trap here is that candidates often confuse the direction of the manager relationship, assuming the incident must be assigned to the user's manager rather than the user themselves, or they incorrectly apply the company check to the manager instead of the user.

How to eliminate wrong answers

Option A is wrong because it ignores the assigned_to field entirely, which is a required condition in the ACL; the user must also satisfy a relationship to the assigned user. Option B is wrong because it requires the incident to be assigned to the user themselves, but the correct condition uses the user's manager, not the user. Option D is wrong because it incorrectly checks the manager's company instead of the user's company, and the assignment condition is reversed (incident assigned to the user, not the user's manager).

Full explanation →

352

MCQmedium

A developer needs to invoke a third-party SOAP web service from a business rule. The WSDL is imported and the SOAP message is created. What is the correct way to send the request?

A.Create a SOAPMessage object and use the send() method.

B.Use the XMLDocument object to parse the response only.

C.Use a GlideRecord insert to write the SOAP envelope to a table.

D.Use the RESTMessageV2 object to send the request as a POST.

AnswerA

SOAPMessage's send() method properly sends the SOAP request and returns a SOAPResponse.

Why this answer

The SOAPMessage object, part of the javax.xml.soap API, provides a send() method that handles the entire SOAP request-response cycle over HTTP. This method automatically marshals the SOAP message, sends it to the endpoint defined in the WSDL, and returns the response as a SOAPMessage object, making it the appropriate choice for invoking a SOAP web service from a business rule.

Exam trap

ServiceNow often tests the distinction between SOAP and REST integration methods, and the trap here is that candidates mistakenly choose RESTMessageV2 (Option D) because they assume any HTTP POST can handle SOAP, ignoring that SOAP requires a dedicated API to manage the SOAP envelope, headers, and fault handling properly.

How to eliminate wrong answers

Option B is wrong because XMLDocument is used for parsing XML responses, not for sending SOAP requests; it lacks the capability to transmit the SOAP envelope over HTTP. Option C is wrong because GlideRecord is a database manipulation class for ServiceNow tables and cannot send HTTP requests or handle SOAP message transmission. Option D is wrong because RESTMessageV2 is designed for RESTful web services using JSON/XML over HTTP, not for SOAP web services which require SOAP-specific headers and envelope handling; using it would require manually constructing the SOAP envelope and managing SOAP-specific faults.

Full explanation →

353

Drag & Dropmedium

Drag and drop the steps to create a Client Script in ServiceNow into the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

Why this order

The correct order: navigate, create new, set table and name, choose UI type and trigger, then write script and submit.

Full explanation →

354

MCQmedium

An admin wants to create a report showing the number of incidents created each day for the past month. Which type of report should be used?

A.List report

B.Pie chart

C.Line chart

D.Bar chart

AnswerD

Bar chart effectively shows counts per day.

Why this answer

A bar chart is the correct choice because it is ideal for comparing discrete categories (such as days) over a period (the past month), showing the count of incidents per day. In ServiceNow, the 'Report Builder' allows you to create a bar chart with the 'Created on' field grouped by day and the 'Count' aggregation, which directly visualizes the number of incidents created each day.

Exam trap

ServiceNow often tests the distinction between line charts and bar charts for time-based data, where candidates mistakenly choose a line chart because they think it is always best for time series, but a bar chart is more appropriate for discrete daily counts as it avoids implying a continuous trend between days.

How to eliminate wrong answers

Option A is wrong because a list report simply displays raw data in a table format, which does not visually aggregate or summarize the count of incidents per day, making it inefficient for trend analysis. Option B is wrong because a pie chart shows proportions of a whole (e.g., percentage of incidents by category) and cannot effectively display daily counts over a month, as it would require a slice for each day, making it cluttered and unreadable. Option C is wrong because while a line chart can show trends over time, it is typically used for continuous data (e.g., time series with equal intervals) and can be misleading for discrete daily counts; however, the question specifically asks for the number of incidents created each day, and a bar chart is the standard choice in ServiceNow for such categorical time-based aggregations.

Full explanation →

355

MCQhard

A senior developer has created a complex business rule called 'Asset Assignment' on the 'alm_asset' table that runs after insert. The rule queries the 'User' table to find a manager and assigns the asset to that manager's department via a GlideRecord update. The rule has an order of 100. Another business rule called 'Asset Log' on the same table also runs after insert with an order of 200, which logs the assignment in a separate table. After deploying to production, the 'Asset Log' rule executes but the assignment update from 'Asset Assignment' fails silently. The developer discovers that the 'Asset Assignment' rule has a condition script that references a new field that was not added to the 'alm_asset' table in production. The field exists in the developer's instance but not in production. The developer wants to minimize disruption and fix the issue quickly. Which action should the developer take? A. Change the condition script to check if the field exists before using it, and if not, exit the script gracefully. B. Reorder the business rules so that 'Asset Log' runs first and 'Asset Assignment' runs second, and add a condition to 'Asset Log' to only run if the assignment succeeded. C. Remove the condition from 'Asset Assignment' and move the field existence check into the script, setting the field value only if it exists. D. Deactivate the 'Asset Assignment' business rule until the field is added to the table in production, then reactivate it after the next maintenance window.

A.Reorder the business rules so that 'Asset Log' runs first and 'Asset Assignment' runs second, and add a condition to 'Asset Log' to only run if the assignment succeeded.

B.Remove the condition from 'Asset Assignment' and move the field existence check into the script, setting the field value only if it exists.

C.Deactivate the 'Asset Assignment' business rule until the field is added to the table in production, then reactivate it after the next maintenance window.

D.Change the condition script to check if the field exists before using it, and if not, exit the script gracefully.

AnswerD

This prevents the rule from failing when the field is missing and will work once the field is added.

Why this answer

It is the quickest fix with minimal disruption: by checking if the field exists in the condition script, the business rule gracefully exits without error when the field is missing, and once the field is added, the condition will pass and the rule will run as intended. Option A is incorrect because reordering does not address the root cause; the 'Asset Assignment' rule would still fail due to the missing field. Option B is incorrect because moving the check into the script (instead of the condition) would not prevent the condition script from referencing the missing field; the condition script would still error.

Option C is incorrect because deactivating the rule prevents the intended functionality entirely until the field is added, which is more disruptive than a simple condition check.

Full explanation →

356

MCQeasy

A small business uses ServiceNow to manage IT assets. They have a custom table 'u_company_asset' with fields for asset name, serial number, purchase date, and a reference field 'assigned_to' pointing to the User table. The administrator is asked to add a new field called 'Category' that will contain a short list of categories: Desktop, Laptop, Server, Network. The categories will not change frequently. The administrator also needs to ensure that when a user selects a category, a corresponding icon appears next to the field in the form. What is the most efficient way to accomplish this?

A.Use a List Collector field to allow multiple categories

B.Create a Choice field with the four categories, and then configure a UI policy to show different icons based on the selected value

C.Create a custom table 'u_category' and a reference field on 'u_company_asset' pointing to it

D.Use a single-line text field and manually enter the categories

AnswerB

Choice fields are ideal for static lists. Using a UI policy with client-side scripts can easily update an icon image based on the selected category.

Why this answer

A Choice field provides a drop-down list for predefined values that rarely change, and a UI policy can be configured to display different icons based on the selected category. Option A is wrong because a List Collector is used for multiple selections, not a single category. Option C is wrong because creating a custom table is unnecessary overhead for a fixed list.

Option D is wrong because a single-line text field does not enforce predefined values.

Full explanation →

357

MCQmedium

The exhibit shows an ACL condition script intended to allow read access to an incident only if the user has the 'itil' role and is a member of the incident's assignment group. However, users who are members of the assignment group but do not have the 'itil' role are still able to read the incident. What is the most likely problem?

A.The condition script must return true explicitly for the ACL to deny access.

B.The ACL is set to condition type 'script' but the script is not structured correctly.

C.The isMemberOf method requires a group sys_id, not a user ID.

D.There is another ACL on the incident table that grants read access to users with the 'itil' role without the group membership check.

AnswerD

If another ACL grants access, it overrides the denial from this ACL.

Why this answer

ServiceNow ACLs are evaluated in a hierarchy: if any ACL on the same table and operation grants access, the user is allowed. Even if the intended ACL correctly denies access when the group membership check fails, another ACL that grants read access to users with the 'itil' role (without the group condition) will override the denial. The condition script in the intended ACL never gets a chance to block the user because the granting ACL is evaluated first and returns true.

Exam trap

The trap here is that candidates assume a single ACL's condition script is evaluated in isolation, when in fact ServiceNow evaluates all ACLs for the same table and operation, and a granting ACL elsewhere can override a denying one.

How to eliminate wrong answers

Option A is wrong because ACLs in ServiceNow do not require an explicit 'return true' to deny access; a condition script that returns false will deny access by default. Option B is wrong because the condition type 'script' is correctly set, and the script structure is not inherently flawed; the issue is the presence of a conflicting ACL, not a syntax or structure error. Option C is wrong because the isMemberOf method in ServiceNow accepts either a group sys_id or a group name, not a user ID; the method checks if the current user is a member of the specified group.

Full explanation →

358

MCQeasy

A company is integrating ServiceNow with an external ticketing system using a custom REST API. The integration should push updates from ServiceNow to the external system when a change request is approved. Which ServiceNow feature is best suited for this?

A.REST API Explorer

B.Business Rule with outbound REST call

C.Access Control List (ACL)

D.Scheduled Job

AnswerB

Business Rules can trigger on record updates and make outbound REST calls using the RESTMessageV2 API.

Why this answer

A Business Rule with an outbound REST call is the best fit because it triggers automatically on the 'approved' state change of a change request and can execute a synchronous or asynchronous REST API call to the external ticketing system. This allows real-time push of updates without manual intervention or polling, directly meeting the requirement to push updates upon approval.

Exam trap

The trap here is that candidates may confuse REST API Explorer (a manual testing tool) with the ability to automate outbound calls, or think that a Scheduled Job is appropriate for event-driven integrations, missing the need for real-time, state-change-triggered execution.

How to eliminate wrong answers

Option A is wrong because REST API Explorer is a diagnostic and testing tool for manually constructing and testing REST API calls, not a mechanism to automatically trigger outbound integrations based on record state changes. Option C is wrong because Access Control Lists (ACLs) govern data security and permissions within ServiceNow, not outbound data transmission to external systems. Option D is wrong because Scheduled Jobs run on a time-based interval (e.g., every hour) and cannot react instantly to a record state change like approval; they would introduce latency and require polling logic.

Full explanation →

359

MCQeasy

A company wants to hide a field on a catalog item form when a specific variable is selected. What is the most appropriate way to achieve this?

A.Create a UI Policy that hides the field when the condition is met.

B.Modify the form layout to remove the field.

C.Use a catalog client script to hide the field.

D.Write a client script to set the field's display property to false on load.

AnswerA

UI Policies are the standard way to conditionally show/hide fields on forms.

Why this answer

UI Policies are the standard declarative way to control field visibility, read-only, and mandatory states on ServiceNow catalog item forms based on conditions. Option B is incorrect because modifying the form layout only changes the initial arrangement and does not dynamically hide fields. Option C is incorrect because a catalog client script can be used but is less standard and efficient than a UI Policy for visibility control.

Option D is incorrect because a client script setting the display property is not the recommended approach; UI Policy is specifically designed for such conditional logic.

Full explanation →

360

MCQmedium

A developer wants to add a new field to a table that is part of a scoped application. What is the correct method in Studio?

A.In Studio, right-click the table and select 'Add Field'.

B.Create a new field in the application's schema.

C.Use the Application Builder to add a table extension.

D.Navigate to System Definition > Tables and add the field.

AnswerB

Standard method in Studio.

Why this answer

In a scoped application, the proper method to add a new field is to create it in the application's schema within Studio. Option A is incorrect because right-clicking a table does not provide an 'Add Field' option. Option C is incorrect because Application Builder is used for building applications, not adding fields directly.

Option D is incorrect because System Definition > Tables is for global tables, not scoped application tables.

Full explanation →

361

MCQhard

The business rule has an empty script. What will happen when an incident state changes to 'Resolved'?

A.The business rule will not fire because condition is invalid.

B.Nothing, because there is no script.

C.The business rule will cause an error because script is required.

D.The business rule will still fire and execute default actions.

AnswerB

Correct; the rule fires but does nothing.

Why this answer

The business rule will fire because the condition (incident state changes to 'Resolved') is valid. However, since the script is empty, nothing happens. No default actions are executed.

Option A is wrong because the condition is not invalid; it is valid. Option C is wrong because a script is not required for a business rule to fire. Option D is wrong because there are no default actions; the business rule only runs the script, which is empty.

Full explanation →

362

MCQmedium

A company is integrating ServiceNow with an external system using REST API. The integration is failing with a 401 Unauthorized error. The integration user's credentials are correct and the user has the 'rest_service' role. What is the most likely cause of the failure?

A.The password for the integration user does not meet complexity requirements.

B.The integration user does not have the 'rest_api' role.

C.The OAuth token used for authentication has expired or is invalid.

D.The integration is hitting a table ACL that denies read access.

AnswerC

401 Unauthorized indicates authentication failure; expired/invalid OAuth token is a common cause.

Why this answer

A 401 Unauthorized error indicates that the request lacks valid authentication credentials. Since the integration user's credentials are correct and the user has the 'rest_service' role, the most likely cause is that the OAuth token used for authentication has expired or is invalid. ServiceNow REST API integrations commonly use OAuth 2.0 tokens, which have a finite lifetime and must be refreshed or reissued upon expiration.

Exam trap

The trap here is confusing 401 Unauthorized with 403 Forbidden; candidates often attribute authentication failures to role or ACL issues, but 401 specifically points to missing or invalid credentials, not insufficient permissions.

How to eliminate wrong answers

Option A is wrong because password complexity requirements do not cause a 401 error; they affect password creation or reset, not authentication with an already-valid credential. Option B is wrong because the 'rest_api' role does not exist in ServiceNow; the correct role for REST API access is 'rest_service', which the user already has. Option D is wrong because table ACLs denying read access would result in a 403 Forbidden error, not a 401 Unauthorized error, as ACLs control authorization after authentication succeeds.

Full explanation →

363

MCQeasy

Which of the following is the best practice for referencing a field value in a client script on a ServiceNow form?

A.Using g_l.get('field_name')

B.Using g_form.getValue(document.getElementById('field_name'))

C.Using g_form.getValue('field_name')

D.Using GlideRecord.get() to query the field value

AnswerC

This is the standard client-side API to get the current value of a field on the form.

Why this answer

The correct answer because g_form.getValue('field_name') is the standard client-side API to retrieve the value of a field on a ServiceNow form. Option A is incorrect because g_l.get() is used for GlideAjax calls, not for direct field access. Option B is incorrect because g_form.getValue() does not take a DOM element as an argument; it expects a field name string.

Option D is incorrect because GlideRecord.get() is a server-side method and cannot be used directly in a client script.

Full explanation →

364

MCQmedium

A company has a business rule that runs on update of the Incident table. The rule sets the caller_id field to the sys_id of the user who last modified the record. However, the rule does not fire when an update is made via web services. What is the most likely cause?

A.The business rule's 'When' field is set to 'UI action only' which excludes web service updates.

B.The business rule is inactive.

C.Business rules never run when updates are made via web services.

D.The business rule's condition is 'current.operation() == 'update'' but the web service uses a different operation.

AnswerA

This is correct because the 'UI action only' setting limits the rule to UI-triggered updates.

Why this answer

When the 'When' field of a business rule is set to 'UI action only', the rule only triggers on UI actions and not on web service updates. Option B is incorrect because if the business rule were inactive, it would never fire at all, but the question states it doesn't fire only when updated via web services, so it must be active. Option C is incorrect because business rules do run on web service updates unless specifically excluded.

Option D is incorrect because the condition 'current.operation() == 'update'' would still be true for web service updates since web services use the update operation.

Full explanation →

365

Drag & Dropmedium

Drag and drop the steps to create an ACL (Access Control List) in ServiceNow into the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

Why this order

The sequence: navigate to ACLs, create new, define type/operation/name, set condition, and submit.

Full explanation →

366

Matchingmedium

Match each ServiceNow portal widget property to its purpose.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Runs on the client browser

Runs on the server during rendering

Defines the widget's HTML structure

Styles the widget

Defines widget dependencies on other widgets

Why these pairings

The correct matches are: Name as a unique identifier used in code, ID as the system-assigned sys_id, Roles as access control, and Filter Condition as display condition. Common confusions include swapping Name and ID or mixing Roles with Filter Condition.

Full explanation →

367

MCQmedium

The UI Policy has a 'Reverse if false' checkbox unchecked. When will the UI Policy's actions (such as setting a field mandatory) be applied?

A.When any user accesses a record interactively.

B.When any user accesses a record via any method.

C.When a user with the 'admin' role accesses a record via web services.

D.When a user with the 'admin' role accesses a record interactively (e.g., via the browser).

AnswerA

Correct. The UI Policy actions apply when the condition is true on interactive form loads for any user.

Why this answer

A UI Policy with the 'Reverse if false' checkbox unchecked means that its actions (such as making a field mandatory) are applied only when the UI Policy's condition evaluates to true. UI Policies run on interactive form loads (i.e., when a user accesses a record via the browser). Therefore, when any user interacts with the record and the condition is true, the actions are applied.

Options B and C are incorrect because UI Policies do not run for web services or background operations. Option D is incorrect because it unnecessarily restricts the policy to admin users; UI Policies apply to all users based on conditions, not roles.

Exam trap

The trap is that candidates may think UI Policies run for all access methods (including web services) or that they only apply to admin users. The key is remembering that UI Policies are client-side and run only on interactive form loads.

How to eliminate wrong answers

Option A is wrong because UI Policies do not apply to 'any user' interactively; they are role-sensitive and can be scoped to specific conditions, and the 'Reverse if false' checkbox being unchecked does not change that the policy only runs for interactive access, but the statement is too broad and ignores that admin users have special behavior (e.g., UI Policies with 'Reverse if false' unchecked still apply to admins interactively). Option B is wrong because UI Policies do not apply 'via any method'—they are specifically designed for interactive (browser) form loads and do not run for web services, background scripts, or REST/SOAP API calls. Option C is wrong because UI Policies are never evaluated during web service access, regardless of the user's role; web services use business rules or scripted REST APIs, not UI Policies.

Full explanation →

368

MCQeasy

A ServiceNow developer is creating a new scoped application in Studio to manage IT asset lifecycle. They want to ensure the application is easily identifiable and follows best practices. What should the developer set for the application's name and scope fields?

A.Name: 'IT Asset Lifecycle', Scope: 'x_snc_it_asset_lifecycle'

B.Name: 'ITAM', Scope: 'global'

C.Name: 'Asset Management', Scope: 'x_'

D.Name: 'IT Asset Management', Scope: 'x_snc_itam'

AnswerD

Correct: follows best practices with unique prefix and descriptive name.

Why this answer

Scoped applications in ServiceNow must have a unique scope starting with 'x_' followed by a prefix (often the company acronym, e.g., 'snc') and a meaningful name. The name 'IT Asset Management' is descriptive and follows best practices, while the scope 'x_snc_itam' is properly formatted with the company prefix and a concise identifier, ensuring uniqueness and easy identification in the instance.

Exam trap

The trap here is that candidates often choose a scope that is too long or improperly formatted (like 'x_snc_it_asset_lifecycle') thinking it must match the application name exactly, or they mistakenly believe 'global' can be used for scoped apps, failing to recognize that scoped apps require a unique 'x_' scope.

How to eliminate wrong answers

Option A is wrong because the scope 'x_snc_it_asset_lifecycle' is too long and contains underscores that may cause readability issues; ServiceNow best practices recommend keeping scope names concise (e.g., using an acronym like 'itam') while the name can be descriptive. Option B is wrong because the scope 'global' is reserved for global applications and cannot be used for a scoped application; scoped applications require a custom scope starting with 'x_'. Option C is wrong because the scope 'x_' is incomplete and invalid—it must include a company prefix and a meaningful identifier (e.g., 'x_snc_itam'); a bare 'x_' does not provide uniqueness and will cause conflicts.

Full explanation →

369

MCQhard

A company has a custom table 'project_task' with a reference field to 'project'. The requirement is to ensure that only users in a specific group can select projects in a certain state. Which approach provides the most secure and maintainable solution?

A.Use a reference qualifier on the project field that checks user group and project state.

B.Use a data policy with a condition to restrict the reference field.

C.Use a security rule to prevent selection of certain projects.

D.Use a business rule to check group membership on insert/update.

AnswerA

Reference qualifiers filter the available records in the picker, providing immediate feedback.

Why this answer

Reference qualifiers are the standard way to dynamically filter the list of selectable records in a reference field based on conditions such as user group and project state. This approach provides immediate feedback in the UI and prevents invalid selections altogether. Option B (data policy) can enforce rules on submit but does not filter the picker, so users can still select invalid projects before submission.

Option C (security rule) is designed for access control to records or modules, not for field-level filtering. Option D (business rule) would allow selection and then reject on insert/update, leading to a poor user experience and requiring rollback logic. Therefore, a reference qualifier is the most secure and maintainable solution.

Full explanation →

370

Multi-Selecteasy

Which TWO conditions can be used as triggers for a UI Policy to set a field as mandatory? (Choose two.)

Select 2 answers

A.A record is submitted

B.A specific field value changes

C.The form is loaded

D.An ACL evaluates to false

E.The user has a specific role

AnswersB, C

On change conditions are common for UI Policies.

Why this answer

UI Policies can be triggered by changes to a specific field value or when the form is loaded. ACLs and user roles are not triggers for UI Policies.

Full explanation →

371

MCQhard

Refer to the exhibit. What is the primary issue with this script if it is intended to update all incidents in state 'New' (state=1) to priority 2?

A.The script will not update any records because of a syntax error in setValue.

B.The script will update only the first record because next() is used incorrectly.

C.The script will cause an infinite loop.

D.The script will update records but may cause performance issues.

AnswerC

Updating the same record while iterating over it can trigger conditions that requery the record, leading to an infinite loop.

Why this answer

The primary issue is that calling gr.update() inside the while loop on the same GlideRecord object causes an infinite loop. When a business rule or trigger runs on update and re-queries the same set of records, gr.next() may keep returning true as newly updated records might still satisfy the query condition. Option A is incorrect because setValue syntax is correct.

Option B is incorrect as next() iterates correctly. Option D is a possible secondary effect but not the primary issue.

Full explanation →

372

MCQhard

A mid-sized company heavily relies on ServiceNow for incident management. They have a business rule that runs before insert on the Incident table. The rule dynamically sets the assignment group based on the category of the incident and the location of the caller. To determine the correct group, the script performs a GlideRecord query against a custom table called "u_group_mapping", which contains approximately 5000 records mapping category-location pairs to groups. During peak business hours, when many incidents are created simultaneously, the business rule causes significant delays and occasional timeouts, impacting user experience. The development team has been tasked with optimizing this business rule without changing its functionality. The current script structure is roughly: (function executeRule(current, previous) { var gr = new GlideRecord('u_group_mapping'); gr.addQuery('category', current.category); gr.addQuery('location', current.caller_id.location); gr.query(); if (gr.next()) { current.assignment_group = gr.assignment_group; } })(current, previous); The team wants to reduce the database access overhead. Which optimization technique should the developer implement?

A.Use GlideAggregate to retrieve the count of matching groups

B.Store the mapping in a global script include variable that persists across sessions

C.Create a script include with a static variable to cache the mapping for the duration of the current transaction

D.Move the business rule to run after insert so it does not block the insert

AnswerC

This caches the query results within the same request, reducing database calls.

Why this answer

Caching the mapping data in a static variable within a script include ensures that the GlideRecord query against the 5000-record custom table is executed only once per transaction, rather than on every incident creation. This drastically reduces database access overhead during peak hours, as subsequent invocations of the business rule within the same transaction reuse the cached results, eliminating redundant queries and preventing timeouts.

Exam trap

The trap here is that candidates often confuse caching across sessions (Option B) with caching within a transaction (Option C), mistakenly thinking a global variable is more efficient, but ServiceNow’s architecture requires transaction-scoped caching to avoid stale data and concurrency conflicts.

How to eliminate wrong answers

Option A is wrong because using GlideAggregate to count matching groups does not retrieve the actual assignment group value; it only returns a count, which is useless for setting the assignment group and still requires a separate query to fetch the group. Option B is wrong because storing the mapping in a global script include variable that persists across sessions would introduce concurrency issues and stale data, as the mapping could change between sessions and the variable would not be automatically refreshed, leading to incorrect assignments. Option D is wrong because moving the business rule to run after insert does not reduce database access overhead; it merely shifts the timing, and the same GlideRecord query would still execute, potentially causing delays in post-insert processing and still impacting user experience if the insert itself is blocked by synchronous operations.

Full explanation →

373

Multi-Selectmedium

Which TWO of the following are valid methods to create a custom table in ServiceNow?

Select 2 answers

A.Using a client script to create a table on the fly.

B.Importing a CSV file via Import Set and selecting 'Create table automatically'.

C.By updating the 'sys_db_object' table directly with a new entry.

D.Using the 'Create Table' module in System Definition.

E.Using a database view to combine existing tables and then creating a table from the view.

AnswersB, D

Import Sets can create tables if the import set table does not exist.

Why this answer

Correct: B and D. Option B is valid because importing a CSV via an Import Set with the 'Create table automatically' option generates a new table based on the data structure. Option D is valid because the 'Create Table' module in System Definition provides a standard UI to create custom tables.

Incorrect options: A is wrong because client scripts run in the browser and cannot create database tables. C is wrong because directly inserting into 'sys_db_object' bypasses required table creation processes and is not supported. E is wrong because a database view is a virtual representation of data from existing tables, not a physical table.

Full explanation →

374

MCQeasy

An administrator sees that a client script on a catalog item is not firing. The script is defined in the catalog item's 'Variable Editor' as a 'onSubmit' script. Which is the most likely reason?

A.The script is set to run on 'onLoad', but the page is being cached

B.The script is defined on a variable, but the variable is not on the order form

C.The script is written as a 'Catalog Client Script' but is defined in the 'Variable Editor' of the variable

D.The script uses 'g_form' but the form is not loaded yet

AnswerC

Correct; client scripts for catalog items must be defined in the Catalog Client Scripts related list, not inside a variable definition.

Why this answer

The scenario describes a script defined in the catalog item's 'Variable Editor' as an 'onSubmit' script, which is a variable-level script. However, the question states the script is not firing. The most likely reason is that the script was written as a 'Catalog Client Script' (a global script type) but was incorrectly placed in the 'Variable Editor' of a variable.

Variable-level scripts in the Variable Editor are executed only when that specific variable is present on the form; if the script is actually a Catalog Client Script (which runs on the entire catalog item), it would not execute as expected because it is scoped to the variable, not the item. This mismatch between the intended script type and its location causes the script to fail to fire.

Exam trap

The trap here is that candidates confuse the scope of variable-level scripts (defined in the Variable Editor) with item-level Catalog Client Scripts, assuming any script placed in the Variable Editor will run globally for the catalog item.

How to eliminate wrong answers

Option A is wrong because an 'onSubmit' script fires on form submission, not on page load; caching affects 'onLoad' scripts, not 'onSubmit' scripts. Option B is wrong because if a script is defined on a variable but that variable is not on the order form, the script simply does not execute—it does not cause a 'not firing' issue; the script is correctly scoped but absent. Option D is wrong because 'g_form' is available as soon as the form is loaded, and an 'onSubmit' script runs after the form is fully loaded, so 'g_form' is always accessible at that point.

Full explanation →

375

MCQmedium

A company needs to retrieve all active users whose department is 'Sales' and who have a manager assigned. They are using GlideRecord. Which script will correctly accomplish this?

A.var gr = new GlideRecord('sys_user'); gr.addQuery('active', true); gr.addQuery('department', 'Sales'); gr.addQuery('manager', 'ISNOTEMPTY'); var rows = gr.getRow();

B.var gr = new GlideRecord('sys_user'); gr.addQuery('active', true); gr.addQuery('department', 'Sales'); gr.addQuery('manager', 'ISNOTEMPTY'); gr.query();

C.var gr = new GlideRecord('sys_user'); gr.addQuery('active', true); gr.addQuery('department', 'Sales'); gr.query();

D.var gr = new GlideRecord('sys_user'); gr.get('active', true); gr.get('department', 'Sales'); gr.get('manager', 'ISNOTEMPTY');

AnswerB

Correctly uses addQuery with ISNOTEMPTY for manager.

Why this answer

It correctly adds queries for active = true, department = 'Sales', and manager ISNOTEMPTY, then executes query() to retrieve all matching records. Option A is incorrect because getRow() is not a valid GlideRecord method. Option C lacks the manager condition.

Option D incorrectly uses get() which retrieves a single record by sys_id, not a query.

Full explanation →

Page 5 of 7

All pages

Practice SNOW-CAD by domain

Target a specific domain to shore up weak areas.

Working with Data Platform Features and Integration Integrating and managing application data Automating application logic with business rules and scripts Application development using ServiceNow Studio Creating and customizing tables and data Designing interfaces and user experiences Core Application Development User Interface Development

See all domains with question counts →