Courseiva

ServiceNow Certified Application Developer CAD (SNOW-CAD) — Questions 226–300

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

Take a mock examExam hub
Page 3

Page 4 of 7

Page 5
226
MCQeasy

A ServiceNow developer is integrating with an external system using a REST message. The external system requires a custom header 'X-API-Key' to be included in every request. Where should the developer configure this header to ensure it is automatically included in all REST messages that call this endpoint?

A.In the 'Query Parameters' tab of the REST message definition
B.In the 'HTTP Headers' tab of the REST message definition
C.In the 'Authentication Profile' associated with the REST message
D.In the Scripted REST API used to create the endpoint
AnswerB

Correct: Custom headers are defined here and automatically included in every request.

Why this answer

The 'HTTP Headers' tab in a REST message definition allows you to define custom headers that are automatically included in every request sent to that endpoint. This is the standard location for headers like 'X-API-Key' that must accompany all calls, as they are part of the HTTP request metadata, not query parameters or authentication credentials.

Exam trap

The trap is that candidates assume custom API keys can be passed as query parameters or handled by authentication profiles, but they must be defined in the HTTP Headers tab of the REST message.

How to eliminate wrong answers

Option A is wrong because the 'Query Parameters' tab is for URL query string parameters (e.g., ?key=value), not HTTP headers; placing a header there would result in it being appended to the URL rather than sent as a header, causing the external system to reject the request. Option C is wrong because an 'Authentication Profile' is used for standard authentication methods (e.g., Basic Auth, OAuth) and is not designed to inject arbitrary custom headers; it would not include the 'X-API-Key' header unless the profile specifically supports custom header injection, which is not its intended purpose. Option D is wrong because a Scripted REST API defines the server-side endpoint that receives requests, not the client-side configuration for outbound REST messages; the developer is configuring the outbound call, not the endpoint itself.

Full explanation →
227
MCQhard

A developer implemented the client script shown in the exhibit to auto-populate the assigned-to field based on the task type. However, when the task type is changed, the assigned-to field is not updated. The server-side script 'TaskTypeAjax' is correctly defined and returns a valid sys_id. What is the most likely reason for the failure?

A.The client script does not check if oldValue is different from newValue
B.The Script Include 'TaskTypeAjax' is not client-callable
C.The client script returns on isLoading, preventing execution
D.A UI policy is overriding the assigned-to field
AnswerB

It must be marked as client-callable in its definition.

Why this answer

The client script attempts to call a Script Include named 'TaskTypeAjax' from the client side. By default, Script Includes are not accessible from client scripts unless the 'Client callable' checkbox is enabled in the Script Include record. Since the script is failing to update the assigned-to field, the most likely cause is that 'TaskTypeAjax' is not marked as client-callable, preventing the GlideAjax request from executing successfully.

Exam trap

The trap here is that candidates assume any Script Include can be called from a client script, but ServiceNow enforces an explicit 'Client callable' flag to control access from the browser.

How to eliminate wrong answers

Option A is wrong because checking if oldValue differs from newValue is not required for the GlideAjax call to work; the issue is that the server-side script is not reachable from the client. Option C is wrong because returning on isLoading would prevent the script from running at all, but the question states the script is implemented and the field is not updated, implying the script executes but the Ajax call fails. Option D is wrong because a UI policy overriding the assigned-to field would not prevent the client script from making the Ajax call; it would only override the value after it is set, and the question indicates the server-side script is correctly defined and returns a valid sys_id, so the failure is in the client-server communication.

Full explanation →
228
MCQmedium

A developer needs to create a scheduled job that runs every Monday at 8 AM to update all incidents with a priority of '1' that are still open. Which condition script should be used in the scheduled job?

A.var gr = new GlideAggregate('incident'); gr.addQuery('priority', 1); gr.query();
B.var gr = new GlideRecord('incident'); gr.addEncodedQuery('priority=1^active=true'); gr.query();
C.var gr = new GlideRecord('incident'); gr.get('priority', 1); gr.get('active', true);
D.var gr = new GlideRecord('incident'); gr.addQuery('priority', 1); gr.addQuery('active', true); gr.query();
AnswerD

Correct: chained addQuery calls retrieve all incident records with priority 1 and active true.

Why this answer

D is correct because it uses chained addQuery calls on a GlideRecord for the incident table to filter priority=1 and active=true, then executes the query to retrieve all matching records. Option A incorrectly uses GlideAggregate, which is intended for aggregation, not record retrieval. Option C incorrectly uses get with two arguments, which retrieves a single record and does not combine multiple conditions.

Option B uses addEncodedQuery, which could produce the same results, but the single-answer item expects the standard programmatic approach using addQuery.

Exam trap

The trap is to select B because it also appears to filter correctly; however, in a single-select item the expected best practice is to use chained addQuery calls for programmatic queries rather than an encoded query string.

How to eliminate wrong answers

Option A is wrong because it uses `GlideAggregate` instead of `GlideRecord`, which is designed for aggregation queries (e.g., counting, summing) and does not provide direct record iteration for updates. Option C is wrong because `gr.get('priority', 1)` and `gr.get('active', true)` are used incorrectly; `get()` retrieves a single record by sys_id or a specific field-value pair, not as a query filter, and chaining them does not combine conditions—it overwrites the previous call, resulting in only the last condition being applied.

Full explanation →
229
Drag & Dropmedium

Drag and drop the steps to create a new Update Set 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 Local Update Sets, create new, provide details, set state to In Progress, and submit.

Full explanation →
230
MCQhard

A developer is testing a REST API call to retrieve active users with the ITIL role created since last month. The response returns an error. What is the most likely cause?

A.The Accept header should be application/xml.
B.The query parameter sysparm_query uses a script which is not allowed in REST API calls.
C.The endpoint should be /api/now/table/sys_user_list.
D.The query should use sysparm_fields instead of sysparm_query.
AnswerB

ServiceNow REST API does not evaluate client-side scripts in query parameters; the date must be precomputed.

Why this answer

The error occurs because the sysparm_query parameter in a REST API call to the /api/now/table/sys_user endpoint does not support scripts; it only accepts encoded query strings using operators like '=', '^', 'STARTSWITH', etc. Using a script in sysparm_query violates the REST API specification, which expects a simple query string, not executable code, leading to a bad request error.

Exam trap

ServiceNow often tests the misconception that sysparm_query can accept any JavaScript expression, when in fact it only supports a predefined set of operators and encoded query strings, not arbitrary scripts.

How to eliminate wrong answers

Option A is wrong because the Accept header should be application/json, not application/xml, as the default and most common response format for ServiceNow REST APIs is JSON; using XML would not cause an error but would be non-standard. Option C is wrong because the correct endpoint for querying the sys_user table is /api/now/table/sys_user, not /api/now/table/sys_user_list; the 'sys_user_list' suffix is not a valid table endpoint. Option D is wrong because sysparm_fields is used to specify which fields to return, not to filter records; filtering requires sysparm_query, so replacing sysparm_query with sysparm_fields would not retrieve active users with the ITIL role.

Full explanation →
231
MCQhard

Refer to the exhibit. This script is placed in a business rule on the 'incident' table with the 'When to run' set to 'before' and 'Update' action. The incident table has an ACL that also prevents updates. The business rule runs and shows the error message but the record is still updated. What is the most likely cause?

A.The business rule condition is not met for this specific record.
B.The setAbortAction method is being called on a new record.
C.The ACL is overriding the business rule's setAbortAction.
D.The business rule should be set to 'after' instead of 'before'.
AnswerA

If the condition (e.g., advanced condition) is false, the script does not execute.

Why this answer

The business rule condition is not met for this specific record. In a 'before' business rule, the script runs before the database operation. The setAbortAction(true) method should prevent the update.

However, if the condition defined in the business rule (or a condition within the script) is not satisfied, the setAbortAction may not be called, allowing the update to proceed. The error message shown may come from a different part of the script (e.g., gs.addErrorMessage) that runs regardless, but the abort action is conditional. Option B is incorrect because setAbortAction works on existing records, not new ones; the exhibit likely shows an update.

Option C is incorrect because ACLs do not override setAbortAction; setAbortAction is a server-side abort that prevents the database operation. Option D is incorrect because 'after' business rules cannot abort the operation; 'before' is correct for aborting.

Full explanation →
232
Matchingmedium

Match each ServiceNow scripting API to its function.

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

Concepts
Matches

Database operations (CRUD)

Aggregate queries (sum, count, etc.)

System-level methods (user, session, etc.)

Asynchronous server calls from client

Client-side form manipulation

Why these pairings

The correct matches are: GlideRecord for CRUD operations, GlideSystem for system properties/IDs, and GlideAggregate for aggregate calculations. Common confusions involve swapping the functions of GlideAggregate, GlideDateTime, and GlideUser.

Full explanation →
233
MCQhard

A developer notices that a custom table 'u_project' is not appearing in the 'Create New' menu even though the application scope is set correctly. The table has been created with the 'Create without application' flag unchecked. What is the most likely cause?

A.The 'Extensible' property is set to false.
B.The 'Create new record' property is set to false.
C.The 'Allow Configuration' property is set to false.
D.The table's roles are not assigned to the developer.
AnswerB

The table property 'Create new record' must be enabled for the table to appear in the 'Create New' menu.

Why this answer

The 'Extensible' property controls whether other tables can extend this table, not the menu. Option B is correct because the table property 'Create new record' must be enabled for the table to appear in the 'Create New' menu. Option C is incorrect because the 'Allow Configuration' property affects dictionary attributes, not the new record menu.

Option D is incorrect because role-based access uses ACLs, but the menu visibility is controlled by the 'Create new record' property.

Full explanation →
234
MCQhard

A Business Rule uses 'current.setAbortAction(true)' to stop a record from being saved. However, the record is still saved under certain conditions. Which scenario could cause this?

A.The Business Rule runs after the database operation.
B.The Business Rule is on a table that is extended from a table with a higher order Business Rule.
C.Another Business Rule runs in the same order but sets abort to false.
D.The Business Rule has a condition that is not met.
AnswerA

After rules cannot abort the operation.

Why this answer

`current.setAbortAction(true)` must be called in a Business Rule that runs before the database operation (e.g., 'before' or 'before query' order). If the Business Rule runs 'after' the database operation, the record has already been committed to the database, so aborting the action has no effect on the save. The abort flag only prevents the pending database write; once the write is complete, the flag is irrelevant.

Exam trap

The trap here is that candidates assume `setAbortAction(true)` works regardless of when the Business Rule runs, but the platform only honors the abort flag in 'before' or 'before query' scripts, not in 'after' scripts.

How to eliminate wrong answers

Option B is wrong because a Business Rule on an extended table with a higher order rule does not inherently cause `setAbortAction(true)` to be ignored; order values determine execution sequence, but the abort flag still works if the rule runs before the database operation. Option C is wrong because `setAbortAction(false)` does not override a previous `setAbortAction(true)` in the same transaction; once abort is set to true, it remains true for the current operation, and no other script can reset it to false. Option D is wrong because if the condition is not met, the Business Rule does not execute at all, so `setAbortAction(true)` is never called, and the record saves normally—this is expected behavior, not a scenario where the abort is ignored despite being called.

Full explanation →
235
MCQmedium

When creating a business rule in Studio, a developer wants the rule to run only when the state field changes from 'New' to 'Work in Progress'. Which condition should be used?

A.current.state.changesFrom('New')
B.current.state == 'New' && previous.state == 'Work in Progress'
C.current.state.changesTo('Work in Progress')
D.current.state.changes()
AnswerC

This correctly fires only when state changes to 'Work in Progress'.

Why this answer

ChangesTo('Work in Progress') triggers when the field changes to that specific value. Option A triggers on any change, B triggers when changing from a value, and D checks current and previous values incorrectly.

Full explanation →
236
MCQmedium

A company has a custom table 'u_incident_task' that extends 'task'. The developer wants to add a field 'u_approval' that is a reference to 'sysapproval_approver'. Which method is the correct way to create this field?

A.Create a 'List' field type and set the table to sysapproval_approver.
B.Create a 'Reference' field and set the reference table to 'sysapproval_approver'.
C.Create a 'Reference' field and set the table to 'task' and the reference field to 'sysapproval_approver'.
D.Create a 'Choice' field and populate it with sysapproval_approver values.
AnswerB

This creates a proper reference to the sysapproval_approver table.

Why this answer

A Reference field is designed to create a link from one table to another, storing the sys_id of the target record. Since 'u_approval' needs to point to a specific record in the 'sysapproval_approver' table, a Reference field with the reference table set to 'sysapproval_approver' is the appropriate method. This ensures referential integrity and allows the platform to resolve display values and enforce relationships.

Exam trap

The trap here is that candidates often confuse 'Reference field' with 'List field' or 'Choice field', mistakenly thinking a List can store a single reference or that a Choice can dynamically pull values from another table, when in fact only a Reference field provides the correct relational link and sys_id storage mechanism.

How to eliminate wrong answers

Option A is wrong because a List field stores multiple values as a delimited string, not a single reference to a record in another table, and cannot enforce referential integrity. Option C is wrong because setting the reference table to 'task' and then specifying a reference field to 'sysapproval_approver' is incorrect; the reference table must be the target table itself, not an intermediate table. Option D is wrong because a Choice field stores a predefined set of static values, not dynamic references to records in another table, and cannot link to sysapproval_approver records.

Full explanation →
237
MCQhard

A developer is troubleshooting a UI policy that sets a field to mandatory when another field equals 'Yes'. The UI policy works on desktop but not on the mobile app. What is the most likely cause?

A.The UI policy is set to 'Run on mobile' but the script is incompatible.
B.The field is not available on the mobile form.
C.The mobile app uses a different table.
D.The UI policy is set to 'Run on desktop' only.
AnswerD

UI policies have separate run options for desktop and mobile.

Why this answer

UI policies have a 'Run on desktop' and 'Run on mobile' checkbox. By default, a new UI policy is set to run on desktop only. If the developer did not explicitly check the 'Run on mobile' option, the policy will not execute on the mobile app, causing the mandatory behavior to be absent on mobile while working on desktop.

Exam trap

ServiceNow often tests the distinction between 'Run on desktop' and 'Run on mobile' settings, trapping candidates who assume UI policies automatically apply to all platforms or who confuse this with field availability or table differences.

How to eliminate wrong answers

Option A is wrong because if the UI policy were set to 'Run on mobile', it would execute on mobile regardless of script compatibility; script incompatibility would cause errors, not a silent failure to run. Option B is wrong because if the field were not available on the mobile form, the UI policy would still attempt to run but might fail silently or show an error, but the question states the policy works on desktop, implying the field exists on the table; mobile forms typically include the same fields unless explicitly removed. Option C is wrong because the mobile app does not use a different table; it uses the same table as the desktop, and UI policies are table-scoped, so a different table would break the policy on both platforms.

Full explanation →
238
MCQmedium

A developer needs to create a flow in Flow Designer that sends an email to a manager when a high-priority incident is created. The flow should retrieve the manager's email from the caller's user record. Which data pill should be used to access the caller's manager's email in the 'Send Email' action?

A.{{trigger.caller.manager_record.email}}
B.{{trigger.caller.manager.email}}
C.{{trigger.caller.email}}
D.{{trigger.incident.caller.email}}
AnswerB

Correct dot-walking over the 'manager' reference field to the user record's email.

Why this answer

In Flow Designer, the dot-walking syntax `trigger.caller.manager.email` navigates from the incident record's caller field to the user record, then to the manager reference field (which is a sys_user record), and finally retrieves the email attribute of that manager's user record. This directly accesses the caller's manager's email address without needing an intermediate lookup.

Exam trap

The trap here is that candidates often confuse the field name `manager` with a non-existent `manager_record` or mistakenly use `trigger.incident` instead of `trigger` directly, leading them to pick options that either reference an invalid field or retrieve the wrong user's email.

How to eliminate wrong answers

Option A is wrong because `manager_record` is not a valid field name on the sys_user table; the manager field is a reference field named `manager`, not `manager_record`. Option C is wrong because `trigger.caller.email` retrieves the caller's own email, not the manager's email. Option D is wrong because `trigger.incident.caller.email` uses an incorrect path (`incident` is not a direct child of `trigger` in this context; the correct starting point is `trigger.caller`), and it also retrieves the caller's email rather than the manager's.

Full explanation →
239
MCQhard

A Service Portal widget uses AngularJS. The developer needs to share data between the client script and the HTML template. What is the correct approach?

A.Use $rootScope to make data globally available.
B.Use $scope to store data in the client controller.
C.Use the 'c' object (c.data) provided by the widget framework.
D.Create a custom AngularJS factory to manage data.
AnswerC

The 'c' object is the official way to bind data between server and client in widgets.

Why this answer

In ServiceNow portal widgets, the 'c' object serves as the client-side controller context, and data stored in c.data is accessible in both the client script and the HTML template. This is the recommended approach for sharing data within a widget. Option A is wrong because $rootScope makes data global and can lead to unintended side effects.

Option B is wrong because $scope is not directly used in the widget framework; instead, the 'c' object provides the scoped context. Option D is wrong because AngularJS factories are meant for reusable services, not for widget-specific data binding.

Full explanation →
240
MCQhard

A developer needs to implement a server-side validation that prevents update to a record if a related record's status is 'Closed'. Where should this logic be placed?

A.ACL
B.Client script
C.UI policy
D.Business rule
AnswerD

Business rules execute on the server and can abort transactions based on conditions.

Why this answer

A business rule runs server-side when a record is updated and can enforce the validation before the update occurs. Client scripts and UI policies are client-side and can be bypassed. ACLs are for access control, not validation.

Full explanation →
241
MCQhard

A service portal developer needs to create a spreadsheet-like view for bulk editing incident records directly in the portal. Which ServiceNow feature is designed for this purpose?

A.Use the 'Form' widget with a multi-record template.
B.Use the 'Report' widget with a drill-down option.
C.Use a custom UI macro to display an HTML table with editable cells.
D.Use the 'Data Table' widget with the 'Inline Edit' option enabled.
AnswerD

This widget provides editable grid capabilities for the service portal.

Why this answer

The Data Table widget with inline editing allows users to edit records in a grid format, which is the intended solution for bulk editing in the portal.

Full explanation →
242
Multi-Selecteasy

A developer needs to display a warning message to the user when the 'priority' field is changed to '1 - Critical'. Which TWO client-side implementations can achieve this?

Select 2 answers
A.Business Rule with 'when to run' set to 'before' and script to call g_scratchpad.message
B.UI Policy with condition: 'Priority changes' and action script to call g_form.showFieldMsg()
C.onLoad client script that checks the current value of priority and shows a message
D.Data Policy with condition on priority field and message set
E.onChange client script with a condition to check newValue and call g_form.showFieldMsg()
AnswersB, E

Correct: UI Policies can run client-side scripts on field change.

Why this answer

A UI Policy with the condition 'Priority changes' triggers an action script when the priority field is modified, allowing the use of `g_form.showFieldMsg()` to display an inline warning message on the field. Option E is correct because an onChange client script fires when the 'priority' field changes, and within it you can check `newValue` against '1 - Critical' and call `g_form.showFieldMsg()` to show the warning. Both are client-side implementations that respond to field changes without a server round-trip.

Exam trap

The trap here is that candidates confuse server-side implementations (Business Rules, Data Policies) with client-side ones, or mistakenly think an onLoad script can detect a field change that occurs after the form has loaded.

Full explanation →
243
MCQeasy

Refer to the exhibit. What does this data policy do?

A.Makes 'short_description' mandatory for all incidents regardless of state.
B.Makes 'short_description' mandatory when state is '1' (New).
C.Makes 'state' mandatory when 'short_description' is empty.
D.Makes 'short_description' read-only when state is '1'.
AnswerB

The condition checks if state equals '1', then makes short_description mandatory.

Why this answer

The data policy sets the 'short_description' field as mandatory when the 'state' field equals '1' (New). Option A is wrong because it says mandatory when state is New, but the condition is on state, not on short description. Option C is wrong because it reverses the condition.

Option D is wrong because it ignores the condition.

Full explanation →
244
Multi-Selectmedium

Which TWO GlideRecord methods can be used to create OR conditions in a query? (Choose two.)

Select 2 answers
A.GlideRecord.ORQuery()
B.GlideRecord.addEncodedQuery()
C.Using addQuery().addOrCondition() pattern
D.GlideRecord.addOrCondition()
E.GlideRecord.addQuery()
AnswersB, D

addEncodedQuery() can include OR operators in the encoded query string, thus creating OR conditions.

Why this answer

B is correct because `GlideRecord.addEncodedQuery()` allows you to pass an encoded query string that can include OR conditions using the `^OR` operator. This method is a direct way to construct complex queries with OR logic without chaining multiple method calls. D is correct because `GlideRecord.addOrCondition()` explicitly adds an OR condition to the current query, typically used after an initial `addQuery()` call.

Exam trap

The trap here is that candidates confuse `addOrCondition()` with a non-existent `ORQuery()` method, or assume that `addQuery()` can be chained with `addOrCondition()` as a single fluent call, which is syntactically incorrect in ServiceNow.

Full explanation →
245
MCQmedium

A service portal widget is supposed to load data from a table and display it in a list. The widget renders but shows no data. Which is the most likely cause?

A.The table's ACL denies read access to the user.
B.The widget's client script has a syntax error.
C.The portal page is not configured to include the widget.
D.An error in the widget's server script prevents data from being queried.
AnswerD

The server script is the primary data source; a scripting error would cause no data to be returned.

Why this answer

The widget renders (client-side works) but shows no data, indicating the server-side script that queries the table failed. Option A (ACL denial) would typically show an error or empty data but is less common than a script error. Option B (client script syntax error) would affect interactivity, not initial data load.

Option C (portal page not configured) would prevent the widget from rendering entirely.

Full explanation →
246
MCQhard

A developer creates a business rule on the Incident table that executes a GlideRecord query to update related records. The rule runs on 'after' update and queries the Problem table to set a field. However, the update is not being committed. What is the most likely reason?

A.The developer forgot to use gr.insert() instead of gr.update().
B.The GlideRecord query requires an explicit gr.updateMultiple() or gr.commit() to persist changes.
C.After business rules cannot update other tables.
D.The query returns more than 100 records, causing a governor limit.
AnswerB

When updating multiple records, gr.updateMultiple() is needed to commit all changes at once.

Why this answer

In ServiceNow, when a GlideRecord query is used in an 'after' business rule to update records on another table, the changes are not automatically committed. The developer must explicitly call gr.updateMultiple() to persist updates to multiple records, or gr.update() for a single record. Option B correctly identifies this requirement, as the update is not being committed without an explicit method call.

Exam trap

The trap here is that candidates assume GlideRecord updates are automatically committed in any context, but ServiceNow requires explicit update calls in 'after' business rules for cross-table modifications, unlike 'before' rules where changes to the current record are auto-saved.

How to eliminate wrong answers

Option A is wrong because gr.insert() is used to create new records, not update existing ones; the issue here is about updating, not inserting. Option C is wrong because 'after' business rules can indeed update records on other tables; there is no restriction that prevents cross-table updates. Option D is wrong because while governor limits exist (e.g., 10,000 records per query), the problem states the update is not being committed, not that it fails due to a limit; the most likely cause is the missing explicit update call.

Full explanation →
247
MCQeasy

To debug a Business Rule that runs on update, which technique is most efficient?

A.Add a breakpoint in the script.
B.Use the Business Rule debug tool.
C.Use the debugger in Studio.
D.Insert a gs.log() message.
AnswerB

Built-in tool specifically for debugging Business Rules.

Why this answer

The Business Rule debug tool provides a dedicated interface for stepping through business rule execution, inspecting variable values, and identifying issues without modifying code. Options A, C, and D are less efficient: A (breakpoint) and C (Studio debugger) require more setup and are not as streamlined for business rules, while D (gs.log()) requires scrolling through logs and does not offer interactive debugging.

Full explanation →
248
MCQmedium

A developer wants to customize the appearance of a Service Portal theme. Which approach is recommended to ensure maintainability and scalability?

A.Use LESS variables inside each widget's widget styles
B.Edit the default theme record to change primary colors
C.Define CSS custom properties in the theme's stylesheet and use them throughout widgets
D.Apply inline styles directly in widget templates for fine-grained control
AnswerC

CSS variables are globally available and can be updated in one place, making them ideal for theming.

Why this answer

The recommended approach because CSS custom properties (CSS variables) allow centralized theme management in the theme's stylesheet, making them reusable across all widgets without duplication. This ensures maintainability and scalability. Option A is incorrect because LESS variables defined in widget styles are scoped to that widget and not shared globally, leading to duplication.

Option B is incorrect because editing the default theme record directly can be overwritten during upgrades, causing maintenance issues. Option D is incorrect because inline styles are not scalable, hard to maintain, and cannot be overridden systematically.

Full explanation →
249
MCQmedium

An organization needs to import data from a SaaS application that provides a CSV file accessible via a direct URL. Which data source type should be configured?

A.REST data source
B.JDBC data source
C.File data source
D.LDAP data source
AnswerC

File data source can be configured to fetch from a URL.

Why this answer

A File data source can import data from a CSV file accessible via a direct URL. Option A is wrong because a REST data source is used for web services, not direct file URLs. Option B is wrong because a JDBC data source connects to SQL databases.

Option D is wrong because an LDAP data source is used for directory services.

Full explanation →
250
MCQeasy

A developer needs to ensure that a catalog variable of type 'Reference' displays only active users from the sys_user table. Which property configuration should be applied to the variable?

A.Set 'Reference qual' to 'active=true'
B.Set 'Condition' to 'active=true'
C.Set 'Ref qual' to 'active=true'
D.Set 'Default value' to 'active=true'
AnswerC

Ref qual allows a condition to filter the reference list.

Why this answer

The 'Ref qual' (Reference qualifier) property on a reference variable allows you to specify a condition to filter the records displayed in the lookup. Setting it to 'active=true' restricts the reference field to show only active users from the sys_user table, ensuring the developer meets the requirement.

Exam trap

The trap here is that candidates confuse 'Reference qual' with 'Ref qual' or think 'Condition' is the correct property, when in fact 'Ref qual' is the exact property name used on reference variables in ServiceNow.

How to eliminate wrong answers

Option A is wrong because 'Reference qual' is not a valid property name; the correct property is 'Ref qual' (abbreviated). Option B is wrong because 'Condition' is not a property on a reference variable; it is used on other field types like UI policies or data policies. Option D is wrong because 'Default value' sets a pre-selected record, not a filter on the available choices.

Full explanation →
251
MCQmedium

A developer is creating a business rule that updates a field on the incident table whenever the state changes to 'Resolved'. The business rule should only run when the incident is updated via the form, not through web services. Which condition should be used?

A.Set the business rule to run only on 'Submit'.
B.Use the 'Filter Conditions' on the table to exclude web service users.
C.In the condition script, add '!gs.getUser().isWebService()'.
D.Set the 'When to run' to 'Update' and nothing else.
AnswerC

Correct: This prevents execution when the update comes from a web service.

Why this answer

The condition should check if the update did not originate from a web service. The method 'gs.getUser().isWebService()' returns true if the current user is a web service user.

Full explanation →
252
Multi-Selectmedium

A developer is creating a custom table 'u_project_risk' to track risks associated with projects. The table must: (1) Automatically set the 'state' field to 'Open' when a new record is created. (2) Prevent deletion of records if the state is 'Closed'. (3) Display a warning message when a user changes the state from 'In Progress' to 'Closed'. Which THREE approaches should the developer use?

Select 3 answers
A.Set a default value for the 'state' field to 'Open'
B.Create a before business rule to check state on update
C.Create a client script that shows a warning on state change
D.Create a business rule that aborts the delete operation on condition state='Closed'
E.Define a reference qualifier on the 'project' field
AnswersA, C, D

Default value sets initial state.

Why this answer

Setting a default value on the 'state' field to 'Open' ensures that whenever a new record is created in the 'u_project_risk' table, the field automatically populates with 'Open' without requiring any script or business rule. This is a declarative, low-code approach that leverages the platform's built-in default value functionality at the field level, guaranteeing the requirement is met even if the record is created via web services or import sets.

Exam trap

ServiceNow often tests the distinction between server-side and client-side logic; the trap here is that candidates might think a 'before' business rule on update (Option B) is needed for the warning, but warnings must be client-side (Option C), and deletion prevention must be server-side (Option D).

Full explanation →
253
MCQmedium

A ServiceNow developer has created a custom UI page using the 'UI Page' module. The page is accessible via a direct URL, but when the user navigates to it, the page appears blank with no errors in the browser console. What is the most likely cause?

A.The page references an undeployed client script that fails silently
B.The 'Requires role' ACL restricts the page content from rendering for the user
C.The page is not set as 'Published' in the UI Page configuration
D.The page is using the 'direct' processing type instead of 'producer'
AnswerB

ACL restrictions can cause the page to render blank if the user does not have the required role, and no error will appear in console because the server simply omits content.

Why this answer

A blank UI page without console errors often indicates that the page’s content is suppressed by a security restriction, such as a required role ACL that the user does not have. Since there are no errors, the page is being reached but the content is not rendered. Option A is incorrect because an undeployed client script would cause a client-side script error, not a completely blank page with no console errors.

Option C is incorrect because if the page were not set as ‘Published,’ it would typically show an authorization error rather than a blank page. Option D is incorrect because the processing type (direct vs. producer) affects how the page is called but does not cause a blank page when the page is accessed directly.

Full explanation →
254
MCQmedium

An organization uses a scheduled data import to load incident data from an external system into ServiceNow. The import set runs successfully, but the transform map sometimes fails to update certain records because the unique key field (sys_id) from the source does not match the sys_id in ServiceNow due to a different format. The team wants to update existing records based on a custom 'external_id' field in the incident table, which is guaranteed to be unique and correctly populated from the source. The target table already has a unique index on 'external_id'. Which configuration should the developer implement to achieve reliable updates?

A.Use a database view to join the import set and incident table on the external_id field.
B.Modify the existing transform map to use 'update' action and set coalesce on the sys_id field.
C.Create a new transform map with coalesce on the 'external_id' field and map the source field to incident.external_id.
D.Increase the scheduled import frequency to overwrite the records.
AnswerC

Correct: Coalesce on 'external_id' enables matching and updating existing records based on that unique field.

Why this answer

By creating a new transform map with coalesce on the 'external_id' field, the system will use the 'external_id' value from the source to match existing records in the incident table. Since a unique index exists on 'external_id', this ensures reliable updates. Option A is incorrect because a database view does not affect import matching logic.

Option B is wrong because coalesce on 'sys_id' would fail due to format differences. Option D does not address the matching issue—increasing frequency does not improve record matching.

Full explanation →
255
MCQmedium

A data source is configured to import XML files from a REST endpoint. The XML contains nested elements. To properly map the data, which transform map feature is most useful?

A.Field mapping using dot-walk notation in 'Field name to map to' column.
B.Adjust the data source's 'XML parsing' settings.
C.Use 'Choice mapping' to map nested values.
D.Scripted transform with GlideRecord queries.
AnswerD

Scripted transforms provide full control to parse and map nested XML elements using JavaScript, making them the most useful for complex data structures.

Why this answer

Scripted transforms allow custom JavaScript to parse and map nested XML elements using GlideRecord or other APIs, providing full flexibility when dot-walk notation is insufficient or not supported. Option A is incorrect because field mapping with dot-walk notation may not handle complex nested structures or special cases, and the reference to 'setEngine(false)' is invalid. Option B is incorrect because adjusting XML parsing settings affects parsing but not mapping.

Option C is incorrect because choice mapping is for choice fields, not for nested data.

Full explanation →
256
Multi-Selectmedium

Which TWO statements about Database Views in ServiceNow are correct?

Select 2 answers
A.Database Views improve write performance by reducing the number of tables.
B.Database Views are stored as separate physical tables.
C.Database Views allow direct updates to the underlying tables through the view.
D.Database Views can be used to join multiple tables for reporting purposes.
E.Database Views can include fields from parent and child tables.
AnswersD, E

Correct, they are used for reporting across tables.

Why this answer

Database Views in ServiceNow are virtual tables that combine data from one or more tables without storing the data physically. They are primarily used for reporting and data analysis, allowing you to join multiple tables and present a unified dataset. Option D is correct because Database Views are specifically designed to join multiple tables for reporting, enabling complex queries across related records.

Exam trap

ServiceNow often tests the misconception that Database Views are physical tables or that they can improve write performance, when in fact they are virtual and read-only, designed solely for reporting and data aggregation.

Full explanation →
257
MCQmedium

A company has a custom table 'u_asset' with a reference field 'u_location' pointing to 'cmn_location'. When a user changes the location on an asset record, the system must automatically update the location on all related 'u_asset_software' records. Which approach should the developer use?

A.Create a Client Script that runs on load to update related records.
B.Create an ACL to automatically propagate changes.
C.Create a Business Rule that runs on update of the 'u_asset' table and updates related records.
D.Create a UI Policy that sets the location field on related records.
AnswerC

Business Rules run server-side and can update related records.

Why this answer

A Business Rule that runs on the 'update' operation of the 'u_asset' table can directly query and update all related 'u_asset_software' records using GlideRecord. This server-side logic ensures the location change is propagated reliably, regardless of how the asset record is updated (UI, web service, import set, etc.), and it executes within the same database transaction for data consistency.

Exam trap

The trap here is that candidates confuse client-side mechanisms (Client Scripts, UI Policies) with server-side automation, or mistakenly think ACLs can perform data updates, when only a Business Rule can reliably propagate changes across tables on the server side.

How to eliminate wrong answers

Option A is wrong because a Client Script that runs on load cannot update related records; it runs in the browser and can only modify the current form's fields, not perform server-side updates on other tables. Option B is wrong because an ACL (Access Control List) controls read/write permissions on records, not data propagation or automated updates. Option D is wrong because a UI Policy is a client-side mechanism that sets field values on the current form based on conditions; it cannot update records on a different table like 'u_asset_software'.

Full explanation →
258
MCQmedium

A developer is customizing a form layout for the 'incident' table. They want to group related fields into titled sections for better usability. Which approach should they use?

A.Create a UI Page and embed it in the form via an HTML field
B.Add fields to form sections via the Form Layout module
C.Use a catalog client script to rearrange fields dynamically
D.Use a UI Policy to show/hide groups of fields
AnswerB

Form sections allow organizing fields into titled groups on a form.

Why this answer

The Form Layout module in ServiceNow allows administrators to group fields into titled sections on a form, which is the standard way to organize related fields. Option A is incorrect because UI Pages are custom pages that can be embedded via HTML fields, but they are not the standard method for grouping fields. Option C is incorrect because catalog client scripts are used for service catalog forms, not standard incident form layout.

Option D is incorrect because UI Policies control field visibility and behavior based on conditions, but they do not create titled sections for grouping fields.

Full explanation →
259
Multi-Selectmedium

A ServiceNow developer is building an integration using IntegrationHub to connect to a third-party system via REST. The system requires OAuth 2.0 with client credentials grant flow. Which TWO configurations are mandatory for setting up this integration in IntegrationHub?

Select 2 answers
A.OAuth server discovery URL (well-known endpoint)
B.Token request endpoint URL (e.g., https://example.com/oauth/token)
C.Base64 encoding of the client secret
D.Username and password for user impersonation
E.OAuth client ID and client secret from the third-party system
AnswersB, E

Required to obtain an access token.

Why this answer

The client credentials grant flow requires a direct token request endpoint URL where the client sends its credentials (client ID and secret) to obtain an access token. IntegrationHub must be configured with this specific endpoint to complete the OAuth 2.0 handshake, as the grant type does not involve user interaction or discovery endpoints.

Exam trap

ServiceNow often tests the distinction between mandatory and optional OAuth 2.0 configurations, and the trap here is that candidates mistakenly think the well-known discovery URL or Base64 encoding is required, when in fact the client credentials flow only needs the token endpoint and the client credentials themselves.

Full explanation →
260
MCQeasy

What happens when a user changes the state from '2' to '1' on an incident record?

A.Nothing happens because the script does not have a return statement.
B.The record is saved without any message because setAbortAction is ignored in 'before' rules.
C.The record is saved and a message 'State change is not allowed' is shown.
D.The record is not saved and an error message 'State change is not allowed' is displayed.
AnswerD

The condition matches, so the action is aborted and error shown.

Why this answer

In a 'before' business rule, calling `current.setAbortAction(true)` prevents the database operation from completing and displays the error message specified in `gs.addErrorMessage()`. When the state changes from '2' to '1', the script checks for this condition and aborts the save, showing 'State change is not allowed'. This is a standard pattern for enforcing state transition restrictions in ServiceNow.

Exam trap

The trap here is that candidates often confuse 'before' business rules with 'after' rules, mistakenly thinking that `setAbortAction` only works in 'after' rules or that a missing return statement causes the rule to be ignored.

How to eliminate wrong answers

Option A is wrong because a 'before' business rule does not require a return statement; the abort action is controlled by `setAbortAction(true)`, not by a return value. Option B is wrong because `setAbortAction` is fully respected in 'before' rules; it is not ignored, and it prevents the record from being saved. Option C is wrong because the record is not saved when `setAbortAction(true)` is called; the error message is displayed, but the save is aborted.

Full explanation →
261
MCQhard

A large enterprise runs ServiceNow on a single instance. They have a custom table 'u_project_task' that stores task details for projects. Each project task has a reference field to the 'u_project' table. The 'u_project' table has approximately 50,000 records, and the 'u_project_task' table has about 2 million records. Users report that opening a project record and viewing its related tasks takes over 30 seconds. The system uses an out-of-box related list to display tasks. The instance has standard hardware resources. The administrator has already confirmed that there are no performance issues with the database server or network. Which course of action should the administrator take to improve the performance of the related list?

A.Archive project tasks older than 1 year to a separate table to reduce the data volume.
B.Create a database index on the 'u_project' field in the 'u_project_task' table to speed up the join.
C.Increase the glide.ui.related_list.max_timeout property to allow the query more time.
D.Add additional application nodes to the instance to distribute the load.
AnswerB

An index on the foreign key can significantly improve query performance for related lists.

Why this answer

The performance bottleneck is the database query that joins the large 'u_project_task' table (2M records) with the 'u_project' table on the reference field. Without an index on the 'u_project' field in 'u_project_task', the database must perform a full table scan for each related list query. Creating a database index on that foreign key column allows the database to use an index seek, dramatically reducing query time.

Exam trap

The trap here is that candidates often confuse performance tuning with scaling infrastructure or extending timeouts, failing to recognize that the root cause is a missing database index on the foreign key column used in the JOIN.

How to eliminate wrong answers

Option A is wrong because archiving data to a separate table does not eliminate the need for an efficient join; the remaining active tasks could still be numerous, and the query would still perform a full scan without an index. Option C is wrong because increasing the glide.ui.related_list.max_timeout property only extends the allowed execution time, it does not address the root cause of the slow query; the query will still take the same amount of time, just not time out. Option D is wrong because adding application nodes distributes web and business logic load, but the bottleneck is a single database query; additional nodes will not speed up the database join itself.

Full explanation →
262
MCQhard

A developer runs this widget server script and expects data.count to be the number of active incidents. However, the widget displays 'undefined' for data.count. What is the most likely cause?

A.The addQuery method syntax is incorrect; it should use a condition string.
B.The while loop uses next(); it should use hasNext() instead.
C.The script is missing the function parameters (options, data) that provide the data object.
D.GlideRecord requires an initialize() call before query.
AnswerC

Without parameters, data is not defined in the closure.

Why this answer

In ServiceNow widget server scripts, the function signature must include the parameters (options, data) to access the data object that is passed to the client script. Without these parameters, the data variable is undefined, causing data.count to display 'undefined'. The script likely defines the function without parameters or with incorrect ones, so the data object is not available.

Exam trap

ServiceNow often tests the requirement for explicit function parameters in widget server scripts, trapping candidates who assume data is globally accessible or who focus on GlideRecord syntax errors instead of the missing parameter signature.

How to eliminate wrong answers

Option A is wrong because the addQuery method syntax is correct as shown; it accepts a field name and value, not a condition string. Option B is wrong because the while loop using next() is valid and does not require hasNext(); hasNext() is used in GlideAggregate, not GlideRecord. Option D is wrong because GlideRecord does not require an initialize() call before query; the new GlideRecord() constructor initializes the object automatically.

Full explanation →
263
MCQeasy

A developer is creating a new custom table for tracking software licenses. The table must inherit the core fields (sys_id, sys_created_by, etc.) and support extensibility for future sub-tables. Which base table should be used?

A.Use the Configuration Item (cmdb_ci) table as a base
B.Create a new table that extends directly from sys_db_object
C.Extend from the Task table
D.Clone the Incident table and remove unnecessary fields
AnswerB

Incorrect. Extending from sys_db_object is wrong because sys_db_object is a meta table that holds definitions of all tables, not a data table. It does not provide core record fields.

Why this answer

None of the provided options are correct. For a custom table that needs to inherit core system fields (sys_id, sys_created_by, etc.) and support future extensibility, the table should extend from the **Base table** (sys_object). The Base table provides the fundamental record structure and is the recommended starting point for custom tables not tied to specific functionality like tasks or CIs.

Extending from sys_db_object (a meta-table for table definitions), cmdb_ci, Task, or cloning Incident all introduce unnecessary overhead or are architecturally incorrect.

Exam trap

Candidates often mistake sys_db_object for the base record table, but it is a system table for table definitions, not data records. The correct base table is sys_object (the 'Base' table), which is not listed among the options.

How to eliminate wrong answers

Option A is wrong because the Configuration Item (cmdb_ci) table is designed for CMDB-related data and includes fields and relationships specific to configuration management, which would impose unnecessary constraints and overhead for a software license tracking table. Option C is wrong because extending from the Task table would inherit workflow-related fields (e.g., state, priority, assignment) that are irrelevant for a simple license tracking table and would complicate the data model. Option D is wrong because cloning the Incident table and removing fields is not a supported method for creating a base table; it would carry over incident-specific business rules, ACLs, and references, leading to maintenance issues and violating extensibility principles.

Full explanation →
264
MCQeasy

A developer is tasked with writing a business rule that should only execute when the record is being updated and the value of the 'state' field changes from 'In Progress' to 'Resolved'. Which condition should be used in the business rule?

A.current.operation() == 'update' && previous.state == 'In Progress' && current.state == 'Resolved'
B.current.operation() == 'update' && current.state.changesFrom('In Progress') && current.state.changesTo('Resolved')
C.current.operation() == 'update' && current.state.changes() && current.state == 'Resolved'
D.current.operation() == 'update' && current.state == 'Resolved' && previous.state == 'In Progress'
AnswerB

These methods are specifically designed for checking field value transitions.

Why this answer

The changesFrom() and changesTo() methods are the recommended approach for checking field transitions. Options A and D use direct comparison but are less efficient. Option C only checks that state changed, not the specific transition.

Full explanation →
265
Multi-Selectmedium

Which TWO client-side APIs are available in a Service Portal widget to interact with form fields?

Select 2 answers
A.spUtil.setValue()
B.c.data (to bind data to the template)
C.g_form.setValue() (to set a field value in a form)
D.g_list.setValue() (to set a value in a list)
E.$scope (to set values in the controller)
AnswersB, C

c.data is the official way to pass data between server and client in widgets.

Why this answer

The correct answers are B and C. In a Service Portal widget, `c.data` is the primary mechanism for data binding between the server and client. `g_form.setValue()` is available when the widget includes a form (e.g., using the Form widget or a custom form). Option A is incorrect because `spUtil.setValue()` does not exist; `spUtil` has methods like `update` and `addInfoMessage`.

Option D is wrong because `g_list.setValue()` is for list views, not standard forms. Option E is incorrect because `$scope` is AngularJS's scope but the recommended pattern in Service Portal is to use `c.data` for data binding.

Full explanation →
266
MCQhard

Refer to the exhibit. A developer created this Script Include for use in a Service Portal widget. When calling the processor from a client script, the developer passes no 'sysparm_name' parameter. What will be the result?

A.The script will return an empty array.
B.The script will execute the processor's constructor only.
C.The script will throw an error because the method is not allowed.
D.The script will run the getData method by default.
AnswerB

Correct: without sysparm_name, only the constructor runs; no method is executed.

Why this answer

When a Script Include is invoked from a Service Portal widget via a processor, the processor's constructor runs automatically. If no 'sysparm_name' parameter is passed, the processor does not know which method to call, so only the constructor executes. The constructor typically initializes properties but does not return data, resulting in no output.

Exam trap

The trap here is that candidates assume a default method (like getData) runs when no method is specified, but ServiceNow's processor architecture requires an explicit 'sysparm_name' to invoke any method beyond the constructor.

How to eliminate wrong answers

Option A is wrong because an empty array is not returned; the constructor runs and returns nothing unless explicitly coded to return an array. Option C is wrong because no error is thrown; the processor simply does not call any method beyond the constructor. Option D is wrong because the getData method is not called by default; it only runs if the 'sysparm_name' parameter matches its name.

Full explanation →
267
Multi-Selecteasy

Which TWO of the following are valid authentication options for a Scripted REST API in ServiceNow?

Select 2 answers
A.JWT
B.Basic Auth
C.API Key
D.SAML 2.0
E.OAuth 2.0
AnswersB, E

Basic Auth is a supported authentication option for Scripted REST APIs.

Why this answer

Basic Auth is a valid authentication option for Scripted REST APIs in ServiceNow because it allows the API to authenticate requests using a username and password pair encoded in the Authorization header. ServiceNow natively supports Basic Auth for inbound REST calls, making it a straightforward choice for legacy or simple integrations.

Exam trap

ServiceNow often tests the misconception that JWT or API Key are native authentication options for Scripted REST APIs, when in fact ServiceNow only supports Basic Auth and OAuth 2.0 as built-in choices for this specific API type.

Full explanation →
268
MCQmedium

A developer writes a Business Rule to calculate a total on an Aggregate field. The rule runs on 'insert' and 'update' on the parent table. However, the total is not updating correctly when child records are deleted. Why?

A.The Business Rule should use 'current' and 'previous' to detect deletion.
B.The Business Rule should be on the child table's delete event.
C.The Business Rule should also run on 'delete'.
D.The Business Rule should be a Global Business Rule.
AnswerB

Child delete triggers need separate rule on child table.

Why this answer

A Business Rule that runs on 'insert' and 'update' on the parent table will not fire when a child record is deleted, because the delete event occurs on the child table, not the parent. To correctly update an aggregate field on the parent when child records are deleted, the Business Rule must be defined on the child table's 'delete' event. This ensures the rule executes when the child record is removed, allowing the aggregate to be recalculated.

Exam trap

The trap here is that candidates assume a Business Rule on the parent table with a 'delete' event will catch child deletions, but in ServiceNow, the delete event only fires on the table where the record is actually deleted, not on related parent records.

How to eliminate wrong answers

Option A is wrong because 'current' and 'previous' are used to compare field values within the same record, not to detect deletion events on a different table; they cannot trigger a rule on the parent when a child is deleted. Option C is wrong because adding 'delete' to the parent table's Business Rule still does not fire when a child record is deleted—the delete event must be on the child table itself. Option D is wrong because making the rule Global does not change the event trigger; a Global Business Rule still requires the correct table and event (child table delete) to execute.

Full explanation →
269
Multi-Selecteasy

Which TWO data types are available in ServiceNow for storing date and time values?

Select 2 answers
A.Time
B.Date/Time
C.Duration
D.Date
E.Timestamp
AnswersB, D

Stores date and time.

Why this answer

ServiceNow provides two dedicated data types for storing date and time values: 'Date' for calendar dates without time, and 'Date/Time' for combined date and time values. These are the correct choices because they directly map to the platform's field types used in tables like Task and Incident for tracking creation and due dates.

Exam trap

The trap here is that candidates confuse 'Duration' with a time-of-day value, but Duration is specifically for elapsed time intervals (e.g., 1d 2h 30m), not for storing a point in time like a date or time of day.

Full explanation →
270
MCQhard

A scoped application includes a script include that is intended to be used by a business rule in the global scope. The script include is marked as 'Client callable: false' and 'Accessible from: This application only'. The business rule cannot call the script include. Which change fixes this?

A.Set the script include name to start with 'global_'
B.Move the script include to the global scope
C.Change 'Accessible from' to 'All application scopes'
D.Set 'Client callable' to true
AnswerC

Correct; this setting allows the script include to be used by scripts in other scopes.

Why this answer

The business rule in the global scope cannot access a script include restricted to 'This application only'. Changing 'Accessible from' to 'All application scopes' allows the global-scope business rule to invoke the script include, as cross-scope access is controlled by this property. The 'Client callable' setting is irrelevant for server-side business rules.

Exam trap

ServiceNow often tests the misconception that 'Client callable' controls all cross-scope access, but the trap here is that server-side cross-scope access is governed solely by the 'Accessible from' property, not the client-callable flag.

How to eliminate wrong answers

Option A is wrong because prefixing the script include name with 'global_' does not override the 'Accessible from' restriction; naming conventions do not grant cross-scope access. Option B is wrong because moving the script include to the global scope would break the scoped application's encapsulation and is unnecessary when the 'Accessible from' property can be adjusted. Option D is wrong because 'Client callable' controls client-side (browser) access, not server-side invocation by a business rule.

Full explanation →
271
Multi-Selecthard

Which THREE are benefits of extending a table rather than creating a new table from scratch?

Select 3 answers
A.Automatically inherits all business rules and client scripts from the parent
B.Supports creating multiple child tables from the same parent
C.Inherits all fields and relationships from the parent table
D.Child records automatically appear in reports on the parent table
E.Can add new fields specific to the child without modifying the parent
AnswersB, C, E

Multiple child tables can extend a single parent, enabling data polymorphism.

Why this answer

Options B, C, and E are correct. Extending a table allows the child table to inherit all fields and relationships from the parent (C), enables adding new fields specific to the child without modifying the parent (E), and supports creating multiple child tables from the same parent (B). Option A is incorrect because although business rules and client scripts are inherited, they can be overridden and not all automatically apply without configuration.

Option D is incorrect because child records do not automatically appear in parent table reports; reports must be configured to include child tables.

Full explanation →
272
Multi-Selectmedium

A developer needs to create a custom UI page in ServiceNow. Which TWO methods can be used to achieve this? (Choose two.)

Select 2 answers
A.Write a client script that renders HTML dynamically
B.Build a Service Portal widget and embed it in a portal page
C.Define a UI Macro and include it in a form
D.Add a new section to an existing form layout
E.Create a UI Page record in the 'UI Pages' module
AnswersB, E

Service Portal widgets can create pages within a portal context.

Why this answer

The correct answers are B and E. Option E: A UI Page record can be created directly in the 'UI Pages' module, which generates a server-side Jelly script. Option B: Service Portal widgets are a modern approach to building UI components that can be embedded in portal pages, effectively creating custom UI.

Option A is incorrect because client scripts run on the client side and do not create UI pages; they manipulate existing pages. Option C: UI Macros are reusable Jelly snippets, not standalone pages. Option D: Adding a section to an existing form modifies the form layout, not creates a new UI page.

Full explanation →
273
Multi-Selectmedium

Which TWO of the following are valid ways to personalize a Service Portal widget without modifying the original widget code?

Select 2 answers
A.Extend the widget via Widget Library
B.Override the widget's server script via a Business Rule
C.Modify the widget's HTML template directly in the instance
D.Use a Widget Instance option to override properties
E.Create a new widget from scratch
AnswersA, D

Extending a widget via the Widget Library creates a new version that inherits from the original, allowing customization.

Why this answer

Options A and D are correct because they allow personalization without altering the original widget code. Option A: Extending the widget via the Widget Library creates a copy that inherits from the original, enabling modifications without touching the source. Option D: Widget Instance options permit overriding properties like CSS, Angular providers, or client scripts at the instance level.

Option B is incorrect because Business Rules cannot override a widget's server script; server scripts are tightly coupled to the widget and cannot be replaced by a Business Rule. Option C is incorrect because modifying the HTML template directly in the instance alters the original widget code. Option E is incorrect because creating a new widget from scratch is not a method of personalizing an existing widget; it is building a new one.

Full explanation →
274
MCQeasy

A junior developer is creating a new catalog item for requesting software licenses. The catalog item includes several variables such as software name, quantity, and cost center. The business requires that when a user submits the request, the cost center variable should automatically populate with the cost center of the user's manager. The developer has written a script in the 'On Load' catalog client script to populate the cost center field. However, during testing, the cost center field remains empty after the form loads. The developer checks the script and finds it uses GlideAjax to call a Scripted REST API to fetch the manager's cost center. What is the most likely cause of the issue?

A.The cost center variable is read-only and cannot be set by client scripts.
B.The Scripted REST API is not accessible from client scripts due to cross-origin restrictions.
C.The GlideAjax call is missing the callback function.
D.The 'On Load' client script runs before the GlideAjax response is received.
AnswerD

Correct: The script sets the field value before the async response returns.

Why this answer

The 'On Load' catalog client script triggers when the form loads, but GlideAjax makes an asynchronous call to the server. The script continues executing without waiting for the response, so the cost center variable remains empty until the callback fires. Since the callback updates the field asynchronously, the field appears empty on load because the response hasn't arrived yet.

Exam trap

ServiceNow often tests the asynchronous nature of GlideAjax in client scripts, tricking candidates into thinking the issue is a missing callback or a permission problem, when the real flaw is the timing of the response relative to the form load.

How to eliminate wrong answers

Option A is wrong because read-only variables can still be set by client scripts using g_form.setValue(), though the user cannot edit them manually. Option B is wrong because GlideAjax uses the same origin as the instance, so cross-origin restrictions do not apply; it calls a Scripted REST API on the same ServiceNow instance. Option C is wrong because while a missing callback would prevent the response from being processed, the question states the developer used GlideAjax to call the API, implying a callback exists; the core issue is the asynchronous timing, not the absence of a callback.

Full explanation →
275
MCQhard

A UI Macro on a form is causing slow load times. The macro uses multiple GlideRecord queries in its server-side script. The developer wants to optimize performance without altering functionality. Which action is most effective?

A.Load the macro asynchronously using UI Macro configuration
B.Move the queries to a client script using GlideAjax to reduce server load
C.Use g_form.addOption() to populate a reference field instead of building the macro
D.Replace GlideRecord queries with GlideAggregate and cache the results
AnswerD

GlideAggregate reduces the number of queries by using aggregates, and caching avoids repeated calls, but caching alone may not help if data changes frequently. Actually, using GlideAggregate to combine queries is more effective than caching alone.

Why this answer

Replacing multiple GlideRecord queries with a single GlideAggregate query reduces the number of database calls, improving performance. Caching the results further avoids redundant queries. Option A is incorrect because asynchronous loading does not reduce the total server processing.

Option B is incorrect because moving queries to a client script via GlideAjax only shifts the load but still requires server-side processing. Option C is incorrect because g_form.addOption() is for adding options to a select field, which does not address the macro's performance issue.

Full explanation →
276
MCQeasy

A developer needs to import data from a CSV file into a custom table. Which ServiceNow module should be used for this task?

A.Scheduled Jobs
B.Update Sets
C.Import Sets
D.Data Source
AnswerC

Import Sets allow loading data from files and mapping fields.

Why this answer

Import Sets are the correct ServiceNow module for importing data from a CSV file into a custom table. They provide a structured pipeline that maps CSV columns to table fields, with staging tables for validation before final insertion. This is the standard approach for one-time or recurring data imports in ServiceNow.

Exam trap

The trap here is that candidates confuse 'Data Source' (a configuration record within Import Sets) with the overall module, leading them to select D instead of C, but the question asks for the module used to perform the import task.

How to eliminate wrong answers

Option A is wrong because Scheduled Jobs are used for running scripts or actions on a timer, not for importing CSV data into tables. Option B is wrong because Update Sets capture configuration changes (e.g., customizations) for moving between instances, not for importing external data like CSV files. Option D is wrong because Data Source is a sub-component within the Import Sets module that defines the source format (e.g., CSV, JDBC), but it is not the top-level module used to perform the import task.

Full explanation →
277
Multi-Selecthard

Which TWO approaches are valid for applying custom theming to Service Portal? (Choose two.)

Select 2 answers
A.Applying a custom LESS file via Theme and Branding
B.Overwriting widget CSS via widget instance options
C.Modifying the Bootstrap CSS directly
D.Using the CSS Variable Editor in UI Builder
E.Using the Theme and Branding module
AnswersA, E

Correct: Custom LESS files allow advanced styling while maintaining upgradeability.

Why this answer

Modifying Bootstrap CSS directly is not upgrade-safe. Overwriting widget CSS via instance options is not a global theming approach. The correct methods are using the Theme and Branding module and applying custom LESS files.

Full explanation →
278
Multi-Selecteasy

Which three elements are required to create a Service Portal widget that displays data from a table?

Select 3 answers
A.A widget dependency
B.An HTML template
C.A server script (Server-side script)
D.A CSS stylesheet
E.A client controller (AngularJS)
AnswersB, C, E

Defines the widget's user interface.

Why this answer

An HTML template is required because it defines the structure and layout of the widget's user interface. In Service Portal, the HTML template uses AngularJS directives to bind data from the server script and client controller, enabling dynamic rendering of table records.

Exam trap

ServiceNow often tests the misconception that a widget dependency is mandatory for any data display, but in reality, dependencies are only required when importing external scripts or styles, not for basic table queries.

Full explanation →
279
MCQmedium

A company uses an import set to bring in hardware asset data from an external inventory system. The staging table 'u_hardware_staging' maps fields to the 'alm_hardware' table via a transform map. Recently, the import set started failing with the error 'Invalid reference field value: 'PO123' for field 'purchase_order''. The 'purchase_order' field on 'alm_hardware' is a reference to the 'purchase_order' table, and the staging field contains the purchase order number (e.g., 'PO123'). The transform map has a field map that uses the 'Find' and 'Map' functionality to match the purchase order number. The 'purchase_order' table uses the 'number' field as the display value. Which change should the administrator make to fix the error?

A.In the transform map, enable 'Find map for each record' and set the match field to 'number' on the purchase_order table
B.Modify the staging table to include the sys_id of the purchase order instead of the number
C.Change the field map to use 'Direct' instead of 'Find' and 'Map'
D.Create a database view between the staging table and the purchase_order table to auto-populate the reference
AnswerA

This configuration will use the number field to look up the corresponding sys_id and populate the reference field correctly.

Why this answer

The transform map needs to find the purchase order record by its 'number' field (display value). Enabling 'Find map for each record' and setting the match field to 'number' on the purchase_order table allows the transform to resolve the reference. Option B is incorrect because the staging table should contain the number, not the sys_id, as the import source provides readable values.

Option C is incorrect because using 'Direct' would attempt to set the reference field with the number string, which is invalid. Option D is incorrect because database views do not apply to transform mappings.

Full explanation →
280
MCQhard

A developer is troubleshooting an integration where an inbound SOAP message fails to insert a record into the 'change_request' table. The SOAP message is well-formed and the user has the 'change_manager' role. The ACL for the 'change_request' table allows write to 'admin' and 'change_manager'. What is the most likely cause?

A.The SOAP message is missing a mandatory field.
B.The 'change_request' table is locked for data imports.
C.The user's role is not recognized when using SOAP web services.
D.The SOAP message uses a different namespace.
AnswerA

Correct: Missing mandatory fields cause the insert to fail.

Why this answer

The most likely cause is that the SOAP message is missing a mandatory field, causing the insert to fail validation. The SOAP web service processes the request and if a required field is omitted, the insert is rejected.

Full explanation →
281
MCQmedium

A company uses a custom application with a table 'incident_task' to track work on incidents. The requirement is to automatically reassign any incident_task that has not been updated in the last 7 days to a specific 'Escalation' group. A developer writes a Business Rule on the 'incident_task' table with the condition 'Current' table and runs on 'before query'. The script checks if (gs.daysAgo(current.sys_updated_on) >= 7) and then performs a current.assignment_group.setValue('escalation_group_sys_id'), followed by current.update(). After testing, the tasks are not being reassigned. What is the most likely cause of this issue?

A.The business rule should be changed to 'after' update.
B.Before query business rules cannot perform updates; they are read-only.
C.The condition should use 'sys_updated_on' instead of 'sys_updated_on' (the same field).
D.The script uses current.update() which causes recursion.
AnswerB

Before query business rules are designed for read operations and any attempt to update will be ignored.

Why this answer

Before query business rules in ServiceNow are executed during the retrieval of records from the database, and they are strictly read-only. They cannot perform updates, inserts, or deletes because the database operation is not yet complete. Attempting to call current.update() within a before query business rule will be ignored or cause an error, which is why the reassignment never occurs.

Exam trap

The trap here is that candidates may think any business rule can update the current record, but ServiceNow explicitly restricts before query rules to read-only operations, and the exam tests this specific constraint.

How to eliminate wrong answers

Option A is wrong because changing the business rule to 'after' update would not help; the issue is that the rule runs on 'before query', which is read-only, and an 'after' update rule would only fire on update operations, not on query. Option C is wrong because the condition already uses 'sys_updated_on' correctly; the field name is not the problem. Option D is wrong because while current.update() can cause recursion in other contexts (e.g., before/after update rules), in a before query rule it is simply not allowed to perform updates at all, so recursion is not the primary issue.

Full explanation →
282
MCQhard

Refer to the exhibit. A developer created this Script Include to be used as a REST API endpoint. However, when calling the API, the response is empty. What is the most likely reason?

A.The Script Include is not marked as 'Client callable'.
B.The function name 'getOpenIncidents' is not exposed.
C.The GlideRecord query returns no results.
D.The Script Include is not marked as 'REST API endpoint' or does not extend the appropriate class.
AnswerD

For REST API, the Script Include must extend 'AbstractAjaxProcessor' and be marked as 'script' for REST, but the exhibit shows it extends AbstractAjaxProcessor, which is correct for GlideAjax, not for REST. Actually, for REST, you need to use 'Scripted REST API' or 'RESTMessage'? Wait, the exhibit shows it extends AbstractAjaxProcessor, which is used for GlideAjax, not for REST API. So the correct answer is that it should be a Scripted REST API instead. But Option B says 'not marked as REST API endpoint' which is the key: it should be a Scripted REST API, not a Script Include. So B is correct.

Why this answer

A Script Include used as a REST API endpoint must either extend the appropriate class (such as 'RESTAPI' or 'RESTAPIV2') or be explicitly marked as a REST API endpoint in its definition. Without this, the platform does not recognize it as a valid endpoint, resulting in an empty response when the API is called.

Exam trap

ServiceNow often tests the misconception that any Script Include can serve as a REST API endpoint if it contains a function, when in reality it must extend the appropriate class or be explicitly marked as a REST API endpoint to be recognized by the platform.

How to eliminate wrong answers

Option A is wrong because 'Client callable' is a property that allows a Script Include to be invoked from client-side scripts (e.g., client scripts or UI policies), but it is not required for REST API endpoints; REST API Script Includes are server-side and do not need this flag. Option B is wrong because the function name 'getOpenIncidents' does not need to be explicitly exposed; REST API Script Includes use a specific method signature (e.g., get() or post()) that the platform automatically routes to based on the HTTP method, not arbitrary function names. Option C is wrong because an empty GlideRecord query would return an empty array or object, not an empty response; the response being empty (no JSON body at all) indicates the endpoint itself is not being reached, not that the query returned no results.

Full explanation →
283
MCQmedium

A developer is creating a custom table for tracking hardware assets. The table must have fields for asset tag, serial number, and purchase date. The developer wants to ensure that the asset tag is automatically generated using a prefix followed by an incrementing number. Which approach should the developer use?

A.Use a calculated value that dot-walks to a number table
B.Set the default value of the asset tag field to 'AST-' + sys_id
C.Create a business rule that calculates the asset tag using a script that increments a counter
D.Configure a dictionary override on the asset tag field to auto-generate
AnswerC

A business rule can generate a unique, incrementing asset tag.

Why this answer

ServiceNow does not have a built-in auto-increment field type, so a business rule must be used to generate a sequential asset tag. The script typically queries the table for the maximum existing number, increments it, and prepends the prefix (e.g., 'AST-0001'). This ensures uniqueness and proper sequencing without relying on sys_id, which is not sequential.

Exam trap

The trap here is that candidates assume sys_id is sequential or that dictionary overrides can generate values, but ServiceNow requires explicit scripting for auto-increment fields, and sys_id is a random GUID, not a sequential number.

How to eliminate wrong answers

Option A is wrong because a calculated value that dot-walks to a number table would not provide a reliable incrementing counter; number tables are static and not designed for dynamic sequence generation. Option B is wrong because using sys_id as part of the default value does not produce an incrementing number; sys_id is a 32-character hexadecimal GUID that is not sequential or human-readable. Option D is wrong because a dictionary override cannot auto-generate values; it only modifies field properties like length, label, or reference, not value generation logic.

Full explanation →
284
Matchingmedium

Match each ServiceNow notification type to its trigger.

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

Concepts
Matches

Sends email based on record conditions

Sends text message

Sends message to Slack channel

Sends alert to mobile app

Makes automated phone call

Why these pairings

Email and SMS notifications are triggered by record events like insert, update, or state change. Scheduled jobs and record deletions are not typical triggers for these notification types.

Full explanation →
285
MCQeasy

A developer needs to add a new table to an existing scoped application in ServiceNow Studio. What is the correct sequence of steps?

A.Open Studio, select the application, click 'Create Application File', choose 'Table', and define the table.
B.Navigate to 'Tables' module, create a new table, and then assign it to the application.
C.Open Studio, select the application, navigate to 'System Definition' > 'Tables' and create the table.
D.Open Studio, go to 'Application Files', click 'New', select 'Table' and configure.
AnswerA

This is the standard method to add a table to a scoped application in Studio.

Why this answer

In ServiceNow Studio, the proper workflow to add a new table to an existing scoped application is to open Studio, select the application, click 'Create Application File', choose 'Table', and then define the table. This ensures the table is created within the application scope, maintaining proper application isolation and metadata association.

Exam trap

The trap here is that candidates may confuse the global 'Tables' module or 'System Definition' > 'Tables' path with the Studio-specific workflow, not realizing that scoped application tables must be created within Studio to maintain proper application context and metadata association.

How to eliminate wrong answers

Option B is wrong because navigating to the 'Tables' module directly creates a table in the global scope, not within the scoped application, which breaks application isolation and may cause conflicts. Option C is wrong because 'System Definition' > 'Tables' is a global navigation path that does not respect the application scope, and Studio does not use that path for scoped table creation. Option D is wrong because 'Application Files' in Studio is used to view existing application files, not to create new tables; the correct entry point is 'Create Application File'.

Full explanation →
286
MCQmedium

A developer is building a custom application that requires a scheduled job to run every hour and check for overdue tasks. In ServiceNow Studio, what is the best way to implement this?

A.Set up a REST API endpoint that external cron jobs call every hour.
B.Create a Business Rule that runs on 'after' insert and update to check for overdue tasks.
C.Use Flow Designer to create a scheduled flow that runs every hour.
D.Create a Scheduled Job in Studio that runs every hour and executes a script to check overdue tasks.
AnswerD

Scheduled Jobs are designed for periodic execution.

Why this answer

ServiceNow Studio provides a native 'Scheduled Jobs' module that allows developers to create and manage recurring server-side scripts directly within the IDE. This approach leverages the platform's job scheduler, which runs on the node's clock and integrates with the glide system, ensuring reliable hourly execution without external dependencies or performance overhead from transactional triggers.

Exam trap

The trap here is that candidates often confuse Business Rules (which are event-driven) with Scheduled Jobs (which are time-driven), assuming any automation logic can be placed in a Business Rule, but the question explicitly requires a time-based schedule, making only a Scheduled Job appropriate.

How to eliminate wrong answers

Option A is wrong because using an external cron job to call a REST API endpoint introduces unnecessary network latency, security overhead (authentication, firewall rules), and dependency on an external system, whereas ServiceNow has a built-in scheduler that runs server-side without external calls. Option B is wrong because a Business Rule runs only on database insert or update operations, not on a time-based schedule, so it cannot check for overdue tasks every hour unless a record is modified, which is not guaranteed. Option C is wrong because Flow Designer scheduled flows are designed for low-code automation but are less efficient for pure script execution; they incur additional overhead from flow engine processing and are not the best practice for simple script-based checks, whereas a Scheduled Job executes a script directly with minimal overhead.

Full explanation →
287
Multi-Selectmedium

Which TWO of the following are valid ways to customize the Service Portal login page?

Select 2 answers
A.Create a new widget instance on the 'loginpage' widget slot.
B.Override the 'Login' page in the portal record by creating a new page and setting it as the login page.
C.Add a widget option to the login widget to inject custom CSS.
D.Use CSS variables in the portal's theme (SCSS) to style the login page elements.
E.Set the 'login.css' property in sys_properties to a custom stylesheet URL.
AnswersB, D

You can create a custom page and set it as the login page.

Why this answer

The Service Portal login page can be customized by overriding the 'Login' page in the portal record. This is done by creating a new page (e.g., a copy of the default login page) and setting it as the login page in the portal's configuration, which allows full control over the layout and widgets used. Option D is correct because CSS variables defined in the portal's theme (SCSS) can be used to style login page elements, as the theme's SCSS is compiled and applied globally to all portal pages, including the login page.

Exam trap

The trap here is that candidates often confuse widget slots with page types, thinking they can add a widget to a 'loginpage' slot (which does not exist), or they assume system properties can be used to inject custom CSS, when in fact Service Portal relies on theme SCSS and page overrides for login page customization.

Full explanation →
288
MCQeasy

A developer is working on a catalog client script that references the 'caller_id' field on the 'sc_req_item' table. The caller_id field references the 'sys_user' table. To get the caller's email, which dot-walking syntax is correct?

A.current.caller_id.email
B.current.caller.email
C.current.caller_id(email)
D.current.caller_id.sys_user.email
AnswerA

Correctly dot-walks from caller_id to the email field on sys_user.

Why this answer

Dot-walking uses the reference field name followed by a dot and the target field. 'caller_id' references the sys_user table, so current.caller_id.email retrieves the caller's email. Option B is wrong because 'caller' is not a field on sc_req_item. Option C is wrong because parentheses are not used in dot-walking.

Option D is wrong because you do not need to specify the table name; the reference is automatically followed.

Full explanation →
289
MCQhard

A large enterprise uses ServiceNow for IT service management. The instance has a custom table 'u_asset_tracker' with over 2 million records. The table is referenced by multiple other tables. Recently, users have reported that when they open a record in the 'u_asset_tracker' table, the form takes 15-20 seconds to load. Additionally, reports that query this table often time out. The instance is running on a mid-range server with 8GB RAM. The admin suspects database performance issues. Upon reviewing the sys_properties, the admin finds that 'glide.ui.auto_clear_filters' is set to false. Also, there are several business rules on the table that run on 'before' query and 'after' query. A script include that transforms data from 'u_asset_tracker' to another table is running frequently. The admin needs to improve performance. Which course of action should the admin take first?

A.Replace all GlideRecord queries with GlideAggregate for reports.
B.Disable the script include that transforms data to reduce load.
C.Review and disable unnecessary 'before query' and 'after query' business rules on the table.
D.Increase the server RAM to 16GB to handle the load.
AnswerC

Correct: These often cause overhead on every query.

Why this answer

Disabling unnecessary 'before query' and 'after query' business rules reduces the overhead on every query, which can significantly improve load times for large tables like 'u_asset_tracker'. Option A is incorrect because replacing GlideRecord with GlideAggregate is not a general performance fix; GlideAggregate is designed for aggregate calculations (e.g., count, sum) and cannot replace standard record retrieval. Option B is incorrect because disabling the script include may break data transformation functionality and is not a targeted performance improvement.

Option D is incorrect because increasing server RAM may help in some cases, but it does not address the root cause of excessive business rule execution on queries.

Full explanation →
290
MCQeasy

An administrator needs to create a custom table to store project-related information. The table must allow records to be assigned to a specific user. Which field type should be used for the assignment field to ensure proper integration with ServiceNow's assignment rules and notifications?

A.Manager
B.Reference to the User table
C.Integer
D.Assignment group
AnswerB

A reference to the User table allows assignment to a specific user. When a record is assigned to a user via a reference field, ServiceNow's assignment rules and notifications can be configured to trigger based on that field, using business rules or assignment rules that check for changes to the field.

Why this answer

Reference to the User table. To assign a record to a specific user, a reference field pointing to the User table is appropriate. ServiceNow's assignment rules and notifications can be configured to trigger based on changes to this user reference field, ensuring proper integration.

Option D (Assignment group) assigns to a group, not an individual, so it does not meet the requirement.

Full explanation →
291
MCQmedium

A developer is building a REST API endpoint in ServiceNow to return data from the 'incident' table. The API should only return incidents assigned to the caller. Which method should be used to filter the records based on the caller's user ID?

A.Use the 'sysparm_display_value' parameter.
B.Use the 'sysparm_query' parameter with an encoded query.
C.Use the 'sysparm_limit' parameter to limit results.
D.Use the 'sysparm_fields' parameter to specify fields.
AnswerB

sysparm_query allows filtering using encoded queries.

Why this answer

The 'sysparm_query' parameter allows you to pass an encoded query string to filter records in a REST API endpoint. By specifying a query like 'assigned_to=javascript:gs.getUserID()' or using the caller's sys_id directly, you can restrict the incident records returned to only those assigned to the caller. This is the standard method for applying dynamic filters in ServiceNow REST API calls.

Exam trap

ServiceNow often tests the distinction between parameters that filter records (sysparm_query) versus those that control output format or field selection, leading candidates to confuse display or field parameters with filtering capabilities.

How to eliminate wrong answers

Option A is wrong because 'sysparm_display_value' controls whether field values are returned as display values or database values, not how records are filtered. Option C is wrong because 'sysparm_limit' restricts the number of records returned but does not filter which records are included based on caller identity. Option D is wrong because 'sysparm_fields' specifies which fields to include in the response, not a condition to filter records.

Full explanation →
292
MCQhard

An organization uses an LDAP integration to import user accounts into ServiceNow. The integration creates a large number of users, but some users are missing their manager field. The manager field in LDAP is a distinguished name (DN). The transform map uses a reference field mapping with "Display value" unchecked. The target field "manager" on sys_user is a reference to sys_user. The import set log shows no errors for those records. What is the most likely cause?

A.The transform map's "Coalesce" field is set on manager.
B.The import set's "On Conflict" setting is set to "Ignore".
C.The LDAP DN values do not match the sys_id of the manager users.
D.The manager field in LDAP is empty for some users.
AnswerC

The mapping expects a sys_id, but the DN is not a sys_id, so the reference cannot be resolved.

Why this answer

The manager field is a reference to sys_user. When mapping an LDAP DN (distinguished name) to a reference field with 'Display value' unchecked, the system expects a sys_id or a value that can be matched via a reference qualifier. Since the DN is not a sys_id and no other matching logic is applied, the mapping fails silently, leaving the field empty.

The import set log shows no errors because the transformation completes but the field is not populated.

Full explanation →
293
MCQeasy

A developer needs to create a catalog item that requires approval from the user's manager. What is the best practice to configure this?

A.Use a Flow with a 'Get Approvals' action
B.Add an 'Approval' activity in the workflow
C.Use a Client Script to trigger an approval request
D.Use a Business Rule to set the approval state
AnswerB

The 'Approval' activity is specifically designed to manage approval processes in workflows.

Why this answer

Adding an 'Approval' activity in a workflow is the standard and best practice for managing approvals in catalog items in ServiceNow. Option A is incorrect because 'Get Approvals' is not a standard action in Flow; Flow does not have a direct 'Get Approvals' action for approval routing. Option C is incorrect because Client Scripts handle client-side behavior and cannot trigger approval requests; approvals are server-side.

Option D is incorrect because Business Rules are not designed for approval routing; they are used for server-side logic on tables, not for orchestrating approval processes.

Full explanation →
294
MCQmedium

A senior developer advises an associate to create a new table for storing incident-related attachments metadata. The table should not have its own workflow or assignments but should be related to incidents. Which table creation approach is best?

A.Create a database view that joins Incident and Attachment tables.
B.Create a table that extends the Attachment table class.
C.Create a table that extends the Incident table.
D.Create a table with a reference field to the Incident table.
AnswerD

A reference field allows linking to Incident without inheriting its behavior, suitable for metadata storage.

Why this answer

The best approach is to create a custom table with a reference field to the Incident table (Option D). This allows storing metadata related to incidents without inheriting Incident's workflow, assignments, or other behaviors. Option A is incorrect because a database view is read-only and cannot store new data.

Option B is incorrect because extending the Attachment table would inherit attachment-specific behaviors and is not appropriate for custom metadata. Option C is incorrect because extending the Incident table would inherit all Incident's features, including workflow and assignments, which the requirement specifically avoids.

Full explanation →
295
MCQhard

A developer is debugging a Business Rule that runs on 'before' but not showing expected behavior. In Studio, which tool can show the execution order and triggered scripts?

A.Scripts Background
B.Update Set
C.Debugger
D.Flow Designer
AnswerC

Correct. Studio's Debugger shows script execution in context.

Why this answer

The Debugger in Studio allows stepping through scripts and viewing execution order, making it ideal for debugging a Business Rule that runs on 'before' but is not showing expected behavior. Option A is wrong; Scripts Background is for running ad-hoc server-side scripts, not for debugging execution order. Option B is wrong; Update Set tracks changes to configuration items, not script execution.

Option D is wrong; Flow Designer is for creating and managing flows, not for debugging script execution order.

Full explanation →
296
MCQhard

A business rule on the Incident table runs 'after' update and calls a script include that modifies the current record. However, changes made by the script include are not saved. What is the reason?

A.The script include uses current.update() which triggers the same business rule recursively.
B.The business rule condition uses current.operation() incorrectly.
C.The script include uses gs.sleep(1000) and times out.
D.The business rule is set to 'after' and cannot modify the current record.
AnswerD

Correct; after rules cannot update the current record.

Why this answer

Business rules set to run 'after' the database operation cannot modify the current record directly; any changes made to the current record in an 'after' business rule are not saved to the database. The script include may alter the record in memory, but since the database write has already occurred, those changes are discarded unless a separate database operation (like current.update()) is explicitly called.

Exam trap

The trap here is that candidates often assume any business rule can modify the current record, overlooking the fundamental difference between 'before' and 'after' execution phases in ServiceNow.

How to eliminate wrong answers

Option A is wrong because current.update() in a script include called from an 'after' business rule would trigger the business rule again, but the issue is that changes are not saved, not that they cause recursion. Option B is wrong because current.operation() is used to check the operation type (e.g., 'insert', 'update'), and an incorrect condition would prevent the rule from running, not cause unsaved changes. Option C is wrong because gs.sleep(1000) would delay execution but not prevent changes from being saved; a timeout would cause an error, not silent failure to save.

Full explanation →
297
Multi-Selectmedium

Which TWO conditions must be met for a transform map to automatically ignore duplicate records during an import?

Select 2 answers
A.The source table has a unique index on the coalesce field.
B.The target table has a unique index on the coalesce field.
C.The coalesce field mapping uses the 'Ignore if Empty' checkbox.
D.The import set table has a unique index on the coalesce field.
E.The transform map has 'Enable Duplicate Detection' set to true.
AnswersB, E

Correct: The target table must have a unique index on the coalesce field for the system to identify and ignore duplicate records.

Why this answer

For duplicate detection to automatically ignore duplicate records already in the target table, two conditions must be met: the transform map must have 'Enable Duplicate Detection' set to true (option E), and the target table must have a unique index on the coalesce field (option B). The coalesce field mapping identifies the field used to check for duplicates; a unique index on the target table enforces uniqueness, allowing the system to detect that a record already exists. Options A, C, and D are incorrect: a unique index on the source table (A) is not required for target duplicate detection; the 'Ignore if Empty' checkbox (C) relates to handling empty values, not duplicate detection; and an index on the import set table (D) is used for detecting duplicates within the same import set, not for ignoring duplicates already in the target.

Full explanation →
298
MCQeasy

A large enterprise is deploying ServiceNow for IT Service Management. The UX team has designed a new portal for end users to request services. The portal should have a modern, responsive design with custom branding. The development team decides to use Service Portal with AngularJS widgets. After initial deployment, the portal loads slowly and some widgets display a blank page. Analysis shows that the widget server scripts are making multiple synchronous GlideRecord queries to the same table, and the client scripts are not handling asynchronous data loading properly. The team needs to optimize the portal performance and fix the blank page issue. Which course of action should the team take?

A.Convert all widgets to use Jelly templates instead of AngularJS to reduce client-side complexity.
B.Replace the Service Portal with a custom UI Page and UI Macro based portal for better performance.
C.Enable server-side caching for the widget server scripts and increase the cache size.
D.Refactor the server scripts to use GlideAggregate for aggregated queries, and ensure the client controller uses $scope.$on to wait for data before rendering.
AnswerD

GlideAggregate reduces database round trips, and proper async handling prevents blank pages.

Why this answer

The performance issue stems from multiple synchronous GlideRecord queries in server scripts, which block the widget rendering. Refactoring to GlideAggregate reduces database round-trips by performing aggregated queries, and using $scope.$on in the AngularJS client controller ensures the view waits for asynchronous data before rendering, fixing the blank page issue.

Exam trap

The trap here is that candidates may think caching (Option C) or switching to legacy technologies (Options A and B) will fix performance, but the question specifically tests understanding of GlideRecord vs. GlideAggregate and AngularJS asynchronous patterns in Service Portal.

How to eliminate wrong answers

Option A is wrong because converting to Jelly templates would not address the root cause of synchronous GlideRecord queries or asynchronous data handling; Jelly is a legacy templating engine that lacks the responsive, modern design capabilities of AngularJS and would not fix the performance or blank page issues. Option B is wrong because replacing Service Portal with custom UI Pages and UI Macros would require significant rework, lose the built-in responsive design and AngularJS framework, and does not solve the underlying query optimization or async data loading problems. Option C is wrong because enabling server-side caching for widget server scripts does not address the synchronous GlideRecord queries that block execution; caching may reduce repeated queries but does not fix the blank page caused by client scripts not waiting for async data, and increasing cache size is irrelevant to the core issue.

Full explanation →
299
MCQeasy

A developer needs to import CSV data into a custom table using Import Sets. The data contains a reference field to a user record. Which configuration ensures that the user record is correctly matched?

A.Set the target field 'email' as coalesce on the transform map.
B.Set the source field as coalesce on the transform map.
C.Configure the import set row to be ignored if the user is not found.
D.Use a script in the 'on before' transform script to find the user.
AnswerA

Using a unique identifier like email as coalesce ensures proper matching.

Why this answer

Setting the 'email' field as a coalesce field on the transform map tells the Import Set engine to use that field to match incoming records against existing target table records. When the reference field points to a user record, the coalesce field (e.g., email) is used to look up the sys_user table and automatically populate the correct sys_id, ensuring the reference is properly resolved without manual scripting.

Exam trap

The trap here is that candidates often confuse 'coalesce' with a field that must be set on the source field (Option B) or think that a script is always required for reference resolution (Option D), when in fact the coalesce field is a declarative, target-side configuration that handles matching automatically.

How to eliminate wrong answers

Option B is wrong because setting the source field as coalesce would attempt to match on the raw source value (e.g., a CSV column name) rather than the target field value, which does not help resolve the reference to the user record. Option C is wrong because ignoring the row if the user is not found would skip the record entirely, preventing any import or error handling, rather than matching or creating the user. Option D is wrong because while an 'on before' script could find the user, it is not the standard or recommended configuration; coalesce fields provide a declarative, no-code solution that is more efficient and maintainable.

Full explanation →
300
MCQmedium

A company is redesigning a service catalog item that has multiple variables. Some variables should only appear when a specific value is selected in a previous variable, and some fields must be mandatory based on the selected options. The development team is debating whether to use UI policies or client scripts for this logic. What is the best practice for implementing such dynamic behavior in a ServiceNow catalog item?

A.Always use client scripts for visibility and mandatory conditions to handle complex scenarios.
B.Configure Access Control Lists (ACLs) to restrict field access based on user roles and variable values.
C.Use UI policies for visibility and mandatory conditions, and use client scripts only for advanced logic that UI policies cannot handle.
D.Use a workflow to control field visibility and mandatory settings based on variable values.
AnswerC

UI policies are the optimal choice for field-level conditions; client scripts supplement when needed.

Why this answer

UI policies are declarative and intended for visibility, read-only, and mandatory conditions, making them easier to maintain and debug. Option A is wrong because client scripts should be used only for complex logic that cannot be achieved with UI policies, not as a default approach. Option B is wrong because ACLs control data access, not form behavior.

Option D is wrong because workflows are for backend processes, not client-side field behavior.

Full explanation →
Page 3

Page 4 of 7

Page 5

All pages

1234567

Practice SNOW-CAD by domain

Target a specific domain to shore up weak areas.

Working with DataPlatform Features and IntegrationIntegrating and managing application dataAutomating application logic with business rules and scriptsApplication development using ServiceNow StudioCreating and customizing tables and dataDesigning interfaces and user experiencesCore Application DevelopmentUser Interface Development
See all domains with question counts →