Courseiva

ServiceNow Certified Application Developer CAD (SNOW-CAD) — Questions 76–150

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

Take a mock examExam hub
Page 1

Page 2 of 7

Page 3
76
MCQeasy

A developer wants to use ServiceNow Studio to create a client script that runs when a form loads and sets a field value based on the current user's department. Which type of client script should be used?

A.onLoad client script
B.onChange client script
C.onSubmit client script
D.onCellEdit client script
AnswerA

onLoad runs when the form is opened.

Why this answer

An onLoad client script runs automatically when a form is opened, making it the correct choice for setting a field value based on the current user's department at the time the form loads. This script type executes in the browser after the form data is retrieved but before the user interacts with the form, allowing immediate field population.

Exam trap

The trap here is that candidates may confuse onLoad with onChange, thinking a field change event is needed to set a value, but the requirement explicitly states 'when a form loads', which directly maps to the onLoad client script type.

How to eliminate wrong answers

Option B is wrong because an onChange client script triggers only when a specific field value changes, not when the form initially loads, so it cannot set the field value on form open. Option C is wrong because an onSubmit client script runs when the form is submitted, which is too late for setting a value on load. Option D is wrong because an onCellEdit client script is used in list or grid views for inline cell editing, not for form load events.

Full explanation →
77
Multi-Selecthard

Which TWO of the following are valid ways to reduce the number of database queries when processing multiple records in a script?

Select 2 answers
A.Use dot-walking to access related table fields.
B.Use multiple GlideRecord queries for each record.
C.Use GlideAggregate for aggregation instead of iterating.
D.Use getValue() to retrieve field values individually.
E.Use GlideRecord's get() method with a sys_id set.
AnswersA, C

Correct. Dot-walking traverses related table fields without additional queries, reducing database calls.

Why this answer

The valid ways to reduce database queries when processing multiple records are A and C. Dot-walking (A) follows relationships without separate queries. GlideAggregate (C) performs aggregation server-side, reducing round trips.

Option E is incorrect because using GlideRecord's get() method with a sys_id still executes a separate database query for each call, so it does not reduce queries. Options B and D increase queries: B uses multiple queries, and D uses getValue() which does not reduce queries since it accesses a field from an already retrieved record.

Full explanation →
78
MCQeasy

A developer needs to count the number of records in the 'task' table that have been updated since the last import. Which GlideAggregate method is correct?

A.gr.addAggregate('COUNT', 'sys_id')
B.gr.addAggregate('COUNT', 'number')
C.gr.addAggregate('COUNT')
D.gr.addAggregate('count')
AnswerA

This correctly counts records by system ID.

Why this answer

`addAggregate('COUNT', 'sys_id')` counts all records in the table, as `sys_id` is always present and unique. Option B is wrong because using `'number'` as the field would only count records where the `number` field is not null, potentially undercounting if any records have a null number. Option C is wrong because `addAggregate('COUNT')` omits the required field name, causing an error.

Option D is wrong because `'count'` (lowercase) is not a valid aggregate function; the function name must be uppercase, e.g., `'COUNT'`.

Full explanation →
79
MCQhard

A custom table 'u_asset' extends the 'cmdb_ci' table. Users report that the 'manufacturer' field is not visible on the 'u_asset' form. What is the most likely cause?

A.The manufacturer field is not part of the cmdb_ci table
B.The u_asset form layout does not include the manufacturer field
C.An ACL on the u_asset table hides the manufacturer field
D.The dictionary entry for manufacturer has mandatory set to false
AnswerB

Child table forms are separate and must be configured to show inherited fields.

Why this answer

The form layout for the custom table 'u_asset' is separate from the parent 'cmdb_ci' form layout. Even though 'manufacturer' is inherited from 'cmdb_ci', it must be explicitly added to the u_asset form layout. Option A is wrong because the manufacturer field is indeed part of the cmdb_ci table.

Option C is incorrect because ACLs control access but do not hide fields from the form layout unless configured; ACLs are not the likely cause. Option D is irrelevant because mandatory setting does not affect visibility.

Full explanation →
80
Multi-Selectmedium

Which THREE of the following are components that can be created directly within ServiceNow Studio?

Select 3 answers
A.Business Rule
B.Report
C.ACL
D.UI Macro
E.Flow
AnswersA, C, D

Created in Studio.

Why this answer

Options A, C, and D are correct: Business Rules, ACLs, and UI Macros can be created directly within ServiceNow Studio. Reports are created in the Reports module, and Flows are created in Flow Designer.

Full explanation →
81
Multi-Selectmedium

Which THREE of the following are attributes of a Service Portal widget? (Choose three.)

Select 3 answers
A.Server Script
B.Client Controller
C.CSS Styling
D.Business Rule
E.HTML Template
AnswersA, B, E

Server Script runs server-side to provide data to the widget.

Why this answer

Server Script is a core attribute of a Service Portal widget because it runs on the server side when the widget is loaded or when a client-initiated action triggers a server call via the 'server.get' or 'server.update' options. It allows developers to query the database, perform business logic, and return data to the client controller, making it essential for data retrieval and processing within the widget lifecycle.

Exam trap

ServiceNow often tests the distinction between widget-specific attributes (Server Script, Client Controller, HTML Template) and platform-wide features like Business Rules or CSS Styling, leading candidates to mistakenly include CSS or Business Rules because they are common in other ServiceNow development contexts.

Full explanation →
82
MCQhard

A developer encounters this error when running a business rule in a scoped application. The table 'x_myapp_incident' was created in the application scope and has records in it. What is the most likely cause?

A.The ACLs on the table restrict access for the script's user.
B.The business rule is trying to access a table in a different scope without using the 'global.' prefix.
C.The application was installed via an update set and the table was not included.
D.The table was removed from the application scope after creation.
AnswerD

If the table is removed from the scope, it becomes inaccessible.

Why this answer

When a table is removed from an application scope after creation, the table still exists in the instance but is no longer associated with the application. Business rules running in the scoped application cannot access tables that are not part of the application's scope, causing an error. This is because scoped applications enforce strict table visibility rules, and only tables explicitly included in the application scope are accessible.

Exam trap

ServiceNow often tests the distinction between a table not existing at all versus a table existing but being out of scope, leading candidates to mistakenly choose options about update sets or ACLs instead of recognizing the scope removal scenario.

How to eliminate wrong answers

Option A is wrong because ACLs control record-level access (read/write/delete), not the ability to reference a table in a script; a missing table error is a compile-time or runtime scope visibility issue, not an ACL denial. Option B is wrong because the table 'x_myapp_incident' already has the application's scope prefix, so it is not in a different scope; the error is about the table being removed from the current scope, not about missing a 'global.' prefix. Option C is wrong because if the application was installed via an update set and the table was not included, the table would simply not exist in the instance; the error message indicates the table exists (it has records) but is not accessible from the scoped application.

Full explanation →
83
MCQhard

A large enterprise is importing 500,000 asset records from an external inventory system using a scheduled data import into the alm_asset table. The transform map uses a coalesce on the 'asset_tag' field to match existing records. The 'asset_tag' field in the target table is a string field with a unique index. The import set table has no unique index on any field. The transform map has 'Enable Duplicate Detection' checked. After the first import, the team notices that many duplicate records were created instead of updating existing ones. There are no errors in the import log. The source data contains only unique asset_tag values. What is the most likely cause of the duplicates?

A.The source data contains multiple records with the same 'asset_tag' but different case.
B.The 'Enable Duplicate Detection' checkbox is not properly configured.
C.The import set table lacks a unique index on the 'asset_tag' field.
D.The coalesce field mapping is incorrectly mapped to the 'asset_tag' field.
AnswerC

Correct: A unique index on the import set table is required for the duplicate detection mechanism to work within the import set; without it, duplicates can be created.

Why this answer

The import set table lacks a unique index on the 'asset_tag' field. For duplicate detection to work properly during an import, the import set table must have a unique index on the coalesce field (here 'asset_tag'). Without that index, the system cannot detect duplicates within the same import set, causing multiple records to be inserted instead of updated.

Option A is incorrect because the source data contains unique asset_tag values, so case differences are not the issue. Option B is incorrect because the 'Enable Duplicate Detection' checkbox is checked, so it is configured. Option D is incorrect because the coalesce field mapping is correctly set to 'asset_tag'.

Full explanation →
84
MCQhard

Refer to the exhibit. A MID Server is failing to connect to an external Oracle database. The error log shows the above message. Which is the most likely cause?

A.The firewall is blocking port 1521.
B.The Oracle client is not installed.
C.The MID Server is not running.
D.The database instance name (service name) is incorrect in the configuration.
AnswerD

Correct: The error indicates the listener does not recognize the service requested.

Why this answer

Error ORA-12514 indicates that the listener received a connection request but the service name (in the connect descriptor) is not known to the listener. This usually means the database service name is incorrect or the listener is not configured for that service.

Full explanation →
85
MCQhard

A Service Portal widget is not updating data on the page after the user clicks a button that calls a server-side function. The client controller uses $scope.server.get() to call the server. The server script updates a global variable in glideRecord and returns it. However, the widget view does not reflect the change. What is the most likely issue?

A.The widget template is not bound to the correct scope variable.
B.The client controller should use $scope.server.update() instead of $scope.server.get().
C.The client controller is not handling the promise returned by $scope.server.get(); the scope update should be inside the success callback.
D.The server script is not allowed to modify data from a widget server script.
AnswerC

The async call returns a promise; scope must be updated after resolution.

Why this answer

`$scope.server.get()` returns a promise, and the scope variables must be updated inside the `.then()` success callback to ensure the changes are applied after the asynchronous server response is received. Without handling the promise, the client controller executes the next line immediately, and the scope update happens before the server data is available, so the widget view never reflects the change.

Exam trap

ServiceNow often tests the asynchronous nature of `$scope.server.get()` and `$scope.server.post()`, trapping candidates who assume the server call is synchronous or that the scope update happens automatically without handling the promise.

How to eliminate wrong answers

Option A is wrong because the widget template binding is not the issue; the problem is that the scope variable is never updated with the server response, not that it is bound to the wrong variable. Option B is wrong because `$scope.server.update()` is used for server-side updates that modify data, but the question describes a `get()` call that returns data; using `update()` would not fix the asynchronous promise handling issue. Option D is wrong because server scripts in Service Portal widgets are fully allowed to modify data via glideRecord; the restriction is that they cannot use `gs.addErrorMessage()` or `gs.addInfoMessage()` directly, but data modification is permitted.

Full explanation →
86
MCQeasy

The business rule above is intended to set the category of an incident based on the correlation_id. However, it is not working as expected. What is the most likely cause?

A.The script is trying to set a field that is read-only before insert.
B.The business rule runs before insert, so the correlation_id field may not have a value yet.
C.The sys_choice table does not contain the choices for the incident category field.
D.The GlideRecord query is incorrectly using 'name' instead of 'table'.
AnswerB

Before insert, the record is new; correlation_id might be empty if not provided.

Why this answer

Business rules that run 'before insert' execute before the record is saved to the database. At that point, the `correlation_id` field may not yet have a value if it is not provided by the user or set by another process. The script attempts to read `current.correlation_id` to determine the category, but if the field is empty, the condition fails and the category is never set.

Exam trap

ServiceNow often tests the misconception that all fields are populated at the time a 'before insert' business rule runs, when in fact only fields explicitly provided in the current operation are available.

How to eliminate wrong answers

Option A is wrong because the incident category field is not read-only before insert; it is a writable field that can be set by business rules. Option C is wrong because the sys_choice table contains the choices for the incident category field by default, and the issue is not about missing choices but about the timing of the script execution. Option D is wrong because the GlideRecord query using 'name' instead of 'table' would cause a different error (invalid table name), but the question describes the rule not working as expected, not throwing an error, and the core issue is the timing of the correlation_id value.

Full explanation →
87
MCQeasy

A company is importing data from a CSV into the 'cmdb_ci' table using an Import Set Row transform map. After running the import, some records were not created. The transform map has a 'Coalese' field set to true on the 'name' field. What is the most likely reason for records not being created?

A.The transform map has incorrect field mappings for the CSV columns.
B.The 'Coalese' field is set to true on the 'name' field, so existing records are updated instead of new ones created.
C.The target table has a data policy that prevents insert from import sets.
D.The CSV file has missing fields that are mandatory on the target table.
AnswerB

Coalesce uses the field to match existing records; if matched, it updates rather than inserts.

Why this answer

Coalese=true on name means if a record with the same name exists, it will update instead of insert. If the name matches an existing record, no new record is created. Option A is wrong because missing fields trigger errors, not silent failure.

Option C is wrong because field mapping issues cause different problems. Option D is wrong because coalesce is for matching, not data type.

Full explanation →
88
Multi-Selectmedium

Which THREE are best practices when working with data imports via Import Sets? (Choose three.)

Select 3 answers
A.Ensure all target fields are mapped to avoid missing data.
B.Use the 'Coalese' field to prevent duplicate records.
C.Map import set rows directly to the target table columns without using a transform.
D.Use a staging table to validate data before transforming.
E.Skip creating a transform map to speed up the import.
AnswersA, B, D

Complete mapping prevents data loss.

Why this answer

Options A, B, and D are correct. Ensuring all target fields are mapped avoids missing data. Using the coalesce field prevents duplicate records.

Using a staging table allows data validation before transforming. Option C is wrong because mapping import set rows directly to the target table without a transform is not a best practice; transforms allow data manipulation and cleansing. Option E is wrong because skipping the transform map would bypass necessary transformations and validations.

Full explanation →
89
MCQmedium

A developer is creating a custom application in ServiceNow Studio and wants to ensure that the application can be easily installed in other instances without conflicts. Which approach should the developer follow?

A.Develop the application in global scope and manually copy components to target instances.
B.Use the 'Application' module in the navigator to create a new application without scope.
C.Create the application with a unique scope prefix in Studio and export as a scoped application.
D.Create the application in the global scope and use update sets for distribution.
AnswerC

Scoped applications provide isolation and easy distribution.

Why this answer

Creating an application with a unique scope prefix in ServiceNow Studio ensures that all application artifacts (tables, scripts, UI elements) are isolated within that scope, preventing naming conflicts with other applications. Exporting as a scoped application allows the application to be installed in other instances via the ServiceNow Store or manual import, preserving its scope isolation and dependencies.

Exam trap

The trap here is that candidates may think update sets (Option D) are a valid distribution method for custom applications, but update sets are designed for configuration changes in global scope and lack the isolation and dependency management that scoped applications provide.

How to eliminate wrong answers

Option A is wrong because developing in global scope and manually copying components to target instances bypasses the scope isolation mechanism, leading to potential naming conflicts and missing dependencies, and is not a supported distribution method. Option B is wrong because the 'Application' module in the navigator does not allow creating an application without a scope; all applications in ServiceNow must have a scope, and creating one without a scope is not possible. Option D is wrong because creating the application in global scope and using update sets for distribution does not provide scope isolation, and update sets can cause conflicts when applied to instances with existing customizations, unlike scoped applications which are self-contained.

Full explanation →
90
MCQmedium

Refer to the exhibit. An inbound REST call (GET) to the 'incident' table is returning a 403 error. The ACL shown in the exhibit is the only ACL on the table. The calling user has the 'incident_manager' role. What is the likely cause of the 403 error?

A.The ACL script is malformed.
B.The ACL requires the 'admin' role, but the user has 'incident_manager'.
C.The ACL operation is 'read' but the REST call is a POST.
D.The user does not have the 'rest_api' role.
AnswerB

Correct: The script checks for 'admin' role, so the user is denied.

Why this answer

The ACL script explicitly requires the 'admin' role. Since the user has 'incident_manager' but not 'admin', the ACL denies access, resulting in a 403 Forbidden error.

Full explanation →
91
MCQmedium

Refer to the exhibit. An IntegrationHub flow using this REST step is failing with a 401 error. What is the most likely cause?

A.The MID Server is not configured with the username and password variables.
B.The endpoint URL is incorrect.
C.The authentication type should be OAuth 2.0.
D.The Content-Type header should be text/plain.
AnswerA

The variables must be defined in the MID Server's configuration file; otherwise, they resolve to empty.

Why this answer

The 401 error indicates an authentication failure. In IntegrationHub, when a REST step uses a MID Server, the MID Server must have the necessary credentials (username and password) stored as variables in its configuration to authenticate with the target endpoint. If these variables are missing or misconfigured, the MID Server cannot supply valid credentials, resulting in a 401 error.

Exam trap

The trap here is that candidates often assume a 401 error always points to an incorrect endpoint or authentication type, rather than recognizing that MID Server credential variables must be explicitly configured for MID Server-based integrations.

How to eliminate wrong answers

Option B is wrong because an incorrect endpoint URL would typically result in a 404 (Not Found) or connection timeout, not a 401 (Unauthorized) error, which specifically indicates an authentication issue. Option C is wrong because the question does not specify that the endpoint requires OAuth 2.0; the existing authentication type (e.g., Basic Auth) could be correct if the credentials are properly configured. Option D is wrong because the Content-Type header being text/plain would cause a data format mismatch or 415 Unsupported Media Type error, not a 401 authentication error.

Full explanation →
92
MCQmedium

A ServiceNow developer is working on a custom application that tracks employee training completions. The application has a table 'u_training' with fields: u_name (string), u_completion_date (date), u_employee (reference to sys_user). The requirement is to automatically send an email to the employee one week before the training completion date. The developer created a scheduled job that runs daily and queries for trainings where the completion date is exactly 7 days from today. However, the email is not being sent. The developer has verified the email notification is configured correctly and the scheduled job runs without errors. The script uses GlideRecord to query the table. What is the most likely reason the email is not sent?

A.The scheduled job is running in a different time zone than the completion date field.
B.The scheduled job runs with a system user that does not have read access to the 'u_training' table.
C.The email notification requires an ACL that the system user does not have.
D.The 'u_completion_date' field is a date/time field but the script compares using date only.
AnswerB

If the job's user lacks read ACL, the query returns no records.

Why this answer

The most likely reason the email is not sent is that the scheduled job runs with a system user that lacks read access to the 'u_training' table. In ServiceNow, scheduled jobs execute under a specific user context (often the 'system' user or the user who created the job). If that user does not have the required read ACL on the table, the GlideRecord query will return zero records, even though the job runs without errors and the email notification is correctly configured.

The developer verified the email configuration and job execution, but did not check the security context of the running job.

Exam trap

The trap here is that candidates often focus on date comparison logic or time zone issues, but the real hidden cause is the security context of the scheduled job, which is a subtle but critical concept in ServiceNow development.

How to eliminate wrong answers

Option A is wrong because time zone differences affect date/time comparisons only if the script uses date/time values without proper conversion; however, the query compares dates using 'exactly 7 days from today' with a date-only field, and ServiceNow's scheduled job runs in the system time zone by default, which is consistent with the database time zone. Option C is wrong because the email notification itself does not require an ACL; the issue is that no records are retrieved to trigger the notification, not that the notification fails due to ACLs. Option D is wrong because if 'u_completion_date' were a date/time field, comparing with date-only would still match records where the time portion is midnight, and the scheduled job's daily run would still find matches; the core problem is the lack of read access, not the field type.

Full explanation →
93
Multi-Selecteasy

Which TWO factors are most important when designing a dashboard for executives to monitor key performance indicators? (Choose two.)

Select 2 answers
A.Including all available metrics
B.Real-time data accessibility
C.Using complex filter conditions
D.Visual clarity and simple layout
E.Detailed transactional data
AnswersB, D

Executives need up-to-date information for decision-making.

Why this answer

Executives need summarized, high-level data that is current and presented clearly. Real-time data accessibility and visual clarity are top priorities.

Full explanation →
94
MCQeasy

A developer needs to display a warning message to the user when a specific field value changes on a form, but the record should still be savable. Which approach should be used?

A.Create a UI Policy with a condition and a UI message.
B.Create a Business Rule that uses gs.addErrorMessage().
C.Create an 'onChange' Client Script using g_form.addErrorMessage() or g_form.showFieldMsg().
D.Create a Data Policy for the field and set a warning message.
AnswerC

Client Script 'onChange' can display a message client-side without preventing save.

Why this answer

An 'onChange' Client Script runs on the client side when a specific field value changes, allowing the developer to display a warning message using g_form.addErrorMessage() or g_form.showFieldMsg() without preventing the record from being saved. This approach ensures the user sees the warning interactively while still being able to submit the form, which matches the requirement exactly.

Exam trap

The trap here is that candidates confuse client-side warnings with server-side blocking mechanisms, often choosing a Business Rule (Option B) because they think gs.addErrorMessage() can display a warning before save, but it actually runs after the record is committed, making it unsuitable for real-time field change notifications.

How to eliminate wrong answers

Option A is wrong because UI Policies are used to make fields mandatory, read-only, or visible based on conditions, and they do not support displaying warning messages without blocking save; they can show UI messages but those are typically informational and not tied to field value changes in a client-side interactive manner. Option B is wrong because Business Rules run server-side after the record is saved, so gs.addErrorMessage() would display the warning only after submission, not when the field value changes on the form, and it could also prevent saving if used with an abort action. Option D is wrong because Data Policies enforce field-level constraints (e.g., mandatory, read-only) on the server side and cannot display warning messages; they are designed to enforce rules, not to show user notifications.

Full explanation →
95
MCQeasy

Which table property can be set to limit the creation of new records to certain roles?

A.Allow attachment
B.Abbreviated table
C.Create access
D.Effective access
AnswerC

This restricts record creation to specified roles.

Why this answer

The 'Create access' property on a table specifies which roles are allowed to create new records. Option A is incorrect: 'Allow attachment' controls whether users can add attachments to records, not creation. Option B is incorrect: 'Abbreviated table' sets a short name or prefix for the table, not access control.

Option D is incorrect: 'Effective access' is a read-only property showing the user's current access rights, not a setting to restrict creation.

Full explanation →
96
MCQmedium

A form has a field 'Department' that, when changed, should make 'Manager' mandatory. The current implementation uses a client script that updates the field attribute on change. However, the mandatory behavior only works when the user first loads the form, but not when changing the field. What is the most likely cause?

A.A UI Policy with same condition is overriding the client script.
B.The client script is not triggered because the field change event is not handled.
C.The script uses g_form.setMandatory() which only works on initial load, not on change.
D.The field is referenced by the wrong name.
AnswerA

UI Policies run after client scripts and can overwrite the mandatory setting.

Why this answer

The script should use a UI Policy instead, as client scripts for such actions require proper event bindings and are less reliable.

Full explanation →
97
MCQeasy

A large enterprise uses a scheduled import to retrieve order data from an external ERP system every night at 2 AM. The import runs a REST API call that returns JSON data, which is processed by an Import Set Row and a Transform Map to populate the custom table 'u_order'. Recently, the import completed with errors: some orders were not imported, and the error log shows 'Record already exists' for those orders. However, when the developer checks the 'u_order' table, the referenced orders do not exist. The developer reviews the Import Set Row and finds that the 'Coalesce' field is set to 'u_order_number', but further investigation reveals that the 'u_order_number' field is not unique in the table; multiple records can have the same order number because they are from different regions. The Transform Map is configured with 'On Success' = 'Update'. What is the best course of action to resolve the issue?

A.Remove the Coalesce field from the Transform Map so that duplicate detection is disabled.
B.Change the 'On Success' action on the Transform Map to 'Insert' to ensure all incoming records are treated as new.
C.Modify the Coalesce field to use a combination of fields (e.g., order number and region) that uniquely identifies each record, or create a dedicated unique identifier.
D.Increase the frequency of the scheduled import to run every hour so that errors are minimized.
AnswerC

A unique coalesce field ensures that the system correctly matches existing records, preventing false 'already exists' errors and allowing proper updates.

Why this answer

The coalesce field must uniquely identify records to avoid false positive matches. Using a combination of fields (e.g., order number and region) ensures each record is uniquely identified. Option A would cause duplicates if the same logical order is reimported.

Option B would also cause duplicates because coalesce is disabled. Option D does not address the root cause of incorrect matching.

Full explanation →
98
MCQeasy

A developer wants to restrict the values in a choice field based on the value of another field on the same record. Which tool should be used?

A.Data policy with conditions.
B.UI policy with 'Choice' action set to 'Set choices' conditionally.
C.Reference qualifier on the choice field.
D.Client script that hides or shows options.
AnswerB

UI policies can dynamically adjust choice lists based on field values.

Why this answer

A UI policy can conditionally set the choices of a choice field on the client side using the 'Choice' action with 'Set choices' conditionally. This allows dynamic filtering of choice values based on other field values on the same record. Option A (data policy) is server-side and cannot dynamically change client-side choices.

Option C (reference qualifier) applies only to reference fields, not choice fields. Option D (client script) can hide or show options but is not the standard declarative approach; UI policy is preferred for this requirement.

Full explanation →
99
Multi-Selecteasy

Which TWO methods are commonly used to prevent performance issues when using GlideRecord in a client script?

Select 2 answers
A.Use GlideRecord directly in client scripts.
B.Use synchronous GlideRecord queries for immediate results.
C.Use a business rule instead to perform the query.
D.Use GlideAjax to call a script include for server-side processing.
E.Limit the number of records retrieved using setLimit().
AnswersD, E

Correct: Client scripts should avoid direct GlideRecord calls.

Why this answer

Options D and E are correct. Using GlideAjax to call a script include moves processing to the server, avoiding synchronous blocking and performance hits in the client. Using setLimit() reduces the number of records retrieved, minimizing data transfer and processing.

Option A is incorrect because GlideRecord is not directly available in client scripts and attempting to use it can cause performance issues. Option B is incorrect because synchronous GlideRecord queries block the UI, degrading user experience. Option C is incorrect because business rules run server-side and do not address client-side performance; GlideAjax is the appropriate client-server communication method.

Full explanation →
100
Multi-Selecthard

A developer is creating a scoped application and needs to reference a global table (e.g., 'sys_user') from a business rule. Which TWO statements are true regarding cross-scope access?

Select 2 answers
A.Scoped applications can create records in global tables via GlideRecord without restrictions.
B.Scoped applications can call global script includes by default.
C.To write to a global table, the application must be granted the 'global' scope or have appropriate ACLs.
D.Scoped applications can update global tables without any additional configuration.
E.Scoped applications can read global tables using the 'global.' prefix.
AnswersC, E

Writing requires explicit permission.

Why this answer

Scoped applications operate within an access control framework that restricts direct writes to global tables. To write to a global table like 'sys_user', the application must either be granted the 'global' scope (which removes scoping restrictions) or have appropriate ACLs that explicitly allow the write operation. Without these, a scoped application's GlideRecord write will fail due to cross-scope access controls enforced by the ServiceNow platform.

Exam trap

ServiceNow often tests the misconception that scoped applications can freely read and write global tables with just the 'global.' prefix, but the trap is that the prefix only grants read access—writes always require additional ACLs or global scope assignment.

Full explanation →
101
MCQeasy

A company needs to prevent updates to a field after a record has been in state 'Closed' for more than 30 days. What is the best approach?

A.Use a Business Rule on query to check state and field value.
B.Use a UI Policy to set field read-only.
C.Use a Business Rule with condition when state changes to Closed, set the field to read-only.
D.Use a Business Rule on update with condition state=Closed and days since closed > 30, and abort action when field is being updated.
AnswerD

Correctly aborts update if condition met.

Why this answer

It uses a Business Rule on update with condition state=Closed and days since closed > 30, and abort action when the field is being updated. This server-side rule directly prevents any updates to the field after the condition is met. Option A (Business Rule on query) runs on query, not on update, so it does not prevent updates.

Option B (UI Policy) is client-side only and can be bypassed by direct web service or scripted updates. Option C (Business Rule when state changes to Closed, set field read-only) only makes the field read-only at the time of closure, but after 30 days it may not be enforced; also read-only is client-side and not a true prevention.

Full explanation →
102
Multi-Selectmedium

Which TWO of the following are valid methods to create a new application scope in ServiceNow Studio?

Select 2 answers
A.Convert a global table to scoped.
B.Import an application from an update set.
C.Use the Application Creation Wizard.
D.Click 'Create Application' in the Studio dashboard.
E.Clone an existing application.
AnswersD, E

Primary method.

Why this answer

The valid methods to create a new application scope in ServiceNow Studio are clicking 'Create Application' in the Studio dashboard (D) and cloning an existing application (E). Options A, B, and C are not valid: converting a global table to scoped does not create an application scope; importing from an update set is for updating existing applications, not creating new ones; the Application Creation Wizard is not a method within Studio.

Full explanation →
103
MCQhard

A developer implements the above Business Rule on the 'incident' table. What is the effect of this script?

A.Deletes the record if the state is closed
B.Prevents the state from ever being set to closed
C.Aborts the update if the record is already in closed state
D.Sets the state to closed for all records
AnswerC

The condition checks if state equals 'closed', and if so, setAbortAction(true) prevents the database operation.

Why this answer

The Business Rule uses 'current.operation() == 'update'' and checks if the state is 'closed' before the update. If the record is already closed, it calls 'gs.addErrorMessage()' and returns false, which aborts the update. This prevents any changes to a closed record, not just preventing the state from being set to closed.

Exam trap

The trap here is that candidates may misinterpret the condition as preventing the state from being set to closed, when in fact it only blocks updates to records that are already closed, not the transition to closed itself.

How to eliminate wrong answers

Option A is wrong because the script does not delete the record; it aborts the update and shows an error message, with no delete operation. Option B is wrong because the script does not prevent the state from being set to closed; it only prevents updates to records that are already in the closed state. Option D is wrong because the script does not set the state to closed; it only checks the current state and aborts the update if it is closed.

Full explanation →
104
MCQmedium

A ServiceNow instance is configured with a custom table 'u_asset_history' that stores historical records for asset changes. This table has a reference field 'u_asset' pointing to the 'alm_asset' table, and a date field 'u_change_date'. The application uses a business rule that runs on 'alm_asset' after update, querying the 'u_asset_history' table to find the most recent change for that asset. The business rule is declared as 'async' to improve performance. However, recently the async business rule has been failing frequently with an 'async queue limit reached' error. The instance has default configuration for transaction quotas. The team suspects that the async queue is getting overloaded because many asset updates are happening simultaneously. Which action should the administrator take to resolve this issue while minimizing impact on other processes?

A.Add an index on the 'u_asset' and 'u_change_date' fields in the 'u_asset_history' table to optimize the query.
B.Increase the system property 'glide.scope.async.quota' to allow more async transactions.
C.Rewrite the business rule to run synchronously with a background script to avoid async queue limits.
D.Disable the business rule and implement a scheduled job to perform the same logic during off-peak hours.
AnswerB

Increasing the async quota allows more concurrent async transactions, resolving the 'async queue limit reached' error.

Why this answer

The error 'async queue limit reached' indicates that the instance's asynchronous transaction queue is full, which is a quota issue. Increasing the system property 'glide.scope.async.quota' raises the maximum number of concurrent asynchronous transactions allowed, directly addressing the overload without changing the business logic or impacting other processes. This is the correct approach because the business rule is already optimized to run asynchronously for performance, and the root cause is a capacity limit, not a query or design flaw.

Exam trap

ServiceNow often tests the distinction between performance optimization (indexing) and capacity management (quotas), leading candidates to mistakenly choose indexing when the error is explicitly a queue limit, not a slow query.

How to eliminate wrong answers

Option A is wrong because adding an index on 'u_asset' and 'u_change_date' would optimize query performance but does not resolve the async queue capacity limit; the error is about transaction quotas, not query speed. Option C is wrong because rewriting the business rule to run synchronously would block the triggering transaction and degrade user experience, defeating the purpose of using async for performance; it also does not address the queue limit. Option D is wrong because disabling the business rule and using a scheduled job would introduce a delay in recording asset history, breaking real-time tracking requirements, and does not solve the underlying queue overload issue.

Full explanation →
105
MCQmedium

A company requires that when the 'state' field on an incident is set to 'Resolved', the 'resolution_code' field must be populated. Which mechanism should be used to enforce this rule?

A.Client script that checks the state and pops up a message.
B.UI policy that sets the resolution_code field mandatory.
C.Business rule with a condition on state change.
D.Data policy with condition state = 'Resolved' and mandatory resolution_code.
AnswerD

Data policies provide server-side validation for field requirements.

Why this answer

Data policies enforce field requirements on server-side updates and apply regardless of how the record is updated (UI, web services, etc.). In this scenario, a data policy with condition state='Resolved' and mandatory resolution_code ensures that the field must be populated when the state is set to Resolved. Option A (client script) is client-side only and can be bypassed.

Option B (UI policy) is also client-side only. Option C (business rule) could be used to enforce the requirement, but data policy is the recommended mechanism for field-level validation because it is simpler and automatically handles all server-side operations. Therefore, option D is correct.

Full explanation →
106
MCQhard

An administrator notices that a scheduled job, 'Update Asset Status', fails every night with a 'Script timeout' error. The job updates a large number of records in the Asset table. Which approach should the administrator take to resolve the timeout issue?

A.Add a business rule to run asynchronously for each update
B.Increase the timeout value in the scheduled job configuration
C.Split the job into multiple smaller jobs running sequentially
D.Rewrite the job to use GlideAggregate with query and update in bulk
AnswerD

Bulk database operations reduce script execution time.

Why this answer

The script timeout error indicates that the scheduled job is taking too long to process individual record updates. Rewriting the job to use GlideAggregate with bulk update operations reduces the number of database round-trips and processes records in batches, which is the standard approach for handling large data sets in ServiceNow without hitting script timeout limits.

Exam trap

ServiceNow often tests the misconception that increasing timeouts or splitting jobs is a valid fix, when the correct answer always involves using bulk database operations like GlideAggregate to reduce processing overhead.

How to eliminate wrong answers

Option A is wrong because adding a business rule to run asynchronously for each update would still trigger individual updates, potentially increasing the load and not resolving the underlying bulk processing issue; business rules are not designed to batch operations. Option B is wrong because increasing the timeout value in the scheduled job configuration only postpones the failure and does not address the root cause of inefficient record-by-record processing; it also risks system instability. Option C is wrong because splitting the job into multiple smaller jobs running sequentially does not change the per-record update pattern; each sub-job would still process records individually, likely still hitting timeouts or extending total execution time unnecessarily.

Full explanation →
107
MCQeasy

A ServiceNow administrator is configuring Single Sign-On (SSO) using SAML 2.0 with a corporate identity provider. Users report that after authenticating, they are redirected back to ServiceNow but see an error: 'Unable to process SAML response. Invalid user.' The administrator checks the SSO log and sees the message: 'No user found with username: [user@company.com]'. The username format in the SAML assertion is userPrincipalName (e.g., user@company.com). ServiceNow user records use the 'User ID' field (e.g., 'user'). What configuration change should the administrator make to resolve this issue?

A.Change the 'NameID format' from 'Unspecified' to 'EmailAddress' in the SAML2 configuration
B.Create an LDAP integration to automatically create ServiceNow users from the identity provider
C.Update all ServiceNow user records to have the 'User ID' field populated as full email addresses
D.Set the 'User Field' property to 'User ID' in the SAML2 configuration to match users based on their User ID
AnswerD

This determines which ServiceNow field is used for lookup; currently it likely defaults to 'User ID' but if set incorrectly, it may fail.

Why this answer

The SAML assertion contains the userPrincipalName (user@company.com), but ServiceNow's default user matching field is the 'User ID' field, which stores only the username (e.g., 'user'). By setting the 'User Field' property to 'User ID' in the SAML2 configuration, ServiceNow will extract the username portion from the NameID (or a custom attribute) and match it against the 'User ID' field, resolving the mismatch. This avoids the need to change user records or the NameID format.

Exam trap

The trap here is that candidates often assume the NameID format (e.g., EmailAddress) must match the user record field, when in fact the 'User Field' property controls the mapping, and the NameID format only affects how the IdP sends the identifier.

How to eliminate wrong answers

Option A is wrong because changing the NameID format from 'Unspecified' to 'EmailAddress' only tells the IdP how to format the NameID in the SAML assertion; it does not change how ServiceNow maps the incoming identifier to a user record. The error is about field mapping, not NameID format. Option B is wrong because creating an LDAP integration would automate user provisioning, but it does not fix the immediate mapping issue; the administrator needs to configure the SAML2 mapping to match existing users, not create new ones.

Option C is wrong because updating all User ID fields to full email addresses would be a workaround that changes the user database schema unnecessarily; the proper fix is to configure the SAML2 mapping to extract the correct portion of the identifier.

Full explanation →
108
MCQhard

A developer is debugging an issue where a Script Action in a Flow Designer flow is not triggering. The flow is configured to run when a record is created or updated in the incident table. The Script Action is supposed to set a field based on a condition, but it never executes. What should the developer check first?

A.Check if the flow is published.
B.Check if the script include used in the Script Action is accessible.
C.Check if the Script Action script has syntax errors.
D.Check the flow's trigger conditions to ensure they match the record update.
AnswerD

The most common issue is that the trigger conditions are not met for the specific record.

Why this answer

The most common reason a Script Action fails to trigger is that the flow's trigger conditions do not match the record update event. Flow Designer evaluates trigger conditions before any actions execute; if the conditions are misconfigured (e.g., expecting a specific field change that isn't occurring), the entire flow, including the Script Action, will not run. The developer should first verify that the trigger conditions align with the actual record creation or update scenario.

Exam trap

The trap here is that candidates often jump to debugging the Script Action itself (syntax, access) without first verifying the fundamental trigger conditions, which is the first logical step in troubleshooting a flow that never starts.

How to eliminate wrong answers

Option A is wrong because a flow must be published to run, but if it were unpublished, the flow would not trigger at all, not just the Script Action; the question states the flow is configured to run, implying it is published. Option B is wrong because an inaccessible Script Include would cause a runtime error in the Script Action, not prevent the Script Action from triggering; the flow would still execute and fail at the script. Option C is wrong because syntax errors in the Script Action script would also cause a runtime error during execution, not prevent the Script Action from being triggered; the flow would still start and reach the action step.

Full explanation →
109
MCQmedium

A table 'u_inventory' has a reference field to the 'Location' table. The developer wants the reference field to display the location name instead of the sys_id in the form. Which attribute should be configured?

A.Default value
B.Reference qualifier
C.Reference display field
D.Display field in the Location table
AnswerC

This attribute sets the field displayed for the referenced record.

Why this answer

'Reference display field'. This attribute on the dictionary entry of the reference field specifies which field from the referenced table (Location) to display in the form. Option A is wrong because 'Default value' sets a default value for the field, not the display.

Option B is wrong because 'Reference qualifier' filters which records are available in the reference field. Option D is wrong because the 'Display' field on the Location table controls the default display of that table's records globally, but for a specific reference field, the 'Reference display field' overrides it.

Full explanation →
110
MCQeasy

Refer to the exhibit. What does this script do?

A.Does nothing because get returns false.
B.Updates the state of incident INC001234 to 2.
C.Creates a new incident.
D.Deletes the incident.
AnswerB

The script uses get() to fetch the record, setValue to change state, and update() to save.

Why this answer

The script retrieves the incident with number 'INC001234' using `get('number', 'INC001234')`, which returns a GlideRecord object. The `get` method returns true if the record exists and loads it into memory. Setting `state` to 2 (which corresponds to 'In Progress' or a similar value) modifies the record, and `update()` commits the change to the database.

Option A is incorrect because `get` returns true if the record is found, so it does do something. Option C would require using `insert()` after setting values, but not `get`. Option D would require `deleteRecord()`, not `update()`.

Full explanation →
111
MCQeasy

What is the most likely cause of this error?

A.The request timed out
B.The access token has expired or is invalid
C.The endpoint URL is incorrect
D.The Content-Type header is missing
AnswerB

A 401 status with Bearer token typically means the token is not accepted.

Why this answer

A 401 Unauthorized error with Bearer authentication typically means the access token is invalid or expired. Therefore, option B is correct. Option A (timeout) would produce a different error (e.g., 504 Gateway Timeout).

Option C (incorrect endpoint URL) would likely result in a 404 Not Found. Option D (missing Content-Type header) might cause a 400 Bad Request, not a 401.

Full explanation →
112
MCQmedium

A developer writes a business rule to run on 'before' update of the Incident table. The rule sets a short description only if it is empty. However, the short description is never set even when it's empty. What is the most likely cause?

A.The developer used gs.setValue() instead of current.setValue().
B.The business rule runs after the database update.
C.The condition 'short_description IS EMPTY' is evaluated on the old value.
D.The business rule is set to run on insert only.
AnswerA

gs.setValue() is not a valid method; current.setValue() must be used to set field values in business rules.

Why this answer

In ServiceNow business rules, `gs.setValue()` is a GlideSystem method that does not exist for setting field values on the current record. The proper method is `current.setValue()`, which directly modifies the field on the current GlideRecord object. Using `gs.setValue()` would result in no change to the short description, even if the condition is met.

Exam trap

The trap here is that candidates may confuse `gs.setValue()` with a valid method, not realizing that `gs` is a system-level object without record manipulation capabilities, and that `current.setValue()` is the required approach for modifying fields on the current record.

How to eliminate wrong answers

Option B is wrong because the business rule is explicitly set to run 'before' update, so it executes prior to the database update, not after. Option C is wrong because the condition 'short_description IS EMPTY' is evaluated on the current value (the new value) in a 'before' update rule, not the old value; the old value is accessed via `current.short_description` before any changes. Option D is wrong because the business rule is explicitly set to run on update (as stated in the question), not on insert only.

Full explanation →
113
Multi-Selecteasy

Which TWO are valid ways to create a new application scope in ServiceNow? (Choose two.)

Select 2 answers
A.Install an update set from an application repository that contains an application scope.
B.Use the 'Create Application' module under System Applications.
C.Use the 'Application Creator' UI page to define a new scope via REST API.
D.Import a v1 update set that includes an application definition.
E.Navigate to 'All' > 'Scopes' and click 'New'.
AnswersA, B

Installing an update set with an application scope creates that scope.

Why this answer

Installing an update set from an application repository that contains an application scope is a standard method to bring a scoped application into an instance. The update set carries the application definition and its scope, and upon commit, ServiceNow creates the application scope automatically if it does not already exist. This is a common approach for distributing scoped applications across instances.

Exam trap

The trap here is that candidates often confuse the 'Create Application' module (which is the correct UI path) with the non-existent 'Scopes' menu or the misleading 'Application Creator' UI page, leading them to select options that describe invalid or legacy methods.

Full explanation →
114
MCQmedium

A developer is designing a custom form in the standard UI (UI16) and needs to add a message that displays only when the 'state' field is 'Closed'. Which feature should be used to achieve this without custom scripting?

A.Create a UI Policy that adds a message when the condition state=Closed is true.
B.Create a form section and set its condition via the 'Conditional' property.
C.Write a Client Script that shows a message when state changes to Closed.
D.Use a UI Macro with a condition that checks the state field.
AnswerA

UI Policies can conditionally display messages without scripting.

Why this answer

UI Policies are the correct declarative feature in UI16 to show a message based on a field value without custom scripting. They run on the client side and can display informational, warning, or error messages when a specified condition (like state=Closed) is met, making option A the appropriate choice.

Exam trap

The trap here is that candidates may confuse UI Policies with Client Scripts, thinking that any client-side behavior requires scripting, when in fact UI Policies provide a no-code alternative for simple conditional actions like showing messages.

How to eliminate wrong answers

Option B is wrong because form sections are used to group fields and can be made conditional via the 'Conditional' property, but they do not display messages; they show or hide entire sections. Option C is wrong because Client Scripts require custom JavaScript code, which the question explicitly says to avoid. Option D is wrong because UI Macros are reusable HTML templates that require scripting to evaluate conditions and are not designed for simple conditional message display without custom code.

Full explanation →
115
MCQhard

A ServiceNow instance is configured to use LDAP for user authentication and role membership. After a recent LDAP schema change, users can authenticate but some users are missing their assigned roles. The LDAP server is returning all attributes correctly. What is the most likely cause of this issue?

A.The 'LDAP Group DN' format in the LDAP server configuration does not match the new schema
B.The LDAP server's base DN for user search has changed
C.The 'Use secure connection' checkbox is unchecked in the LDAP configuration
D.The LDAP server is not returning the 'memberOf' attribute for users
AnswerA

Role mapping uses LDAP groups; if the DN format changed, groups won't be found, so roles are not applied.

Why this answer

The LDAP Group DN format defines how ServiceNow maps LDAP groups to roles. After a schema change, if the DN structure for groups has been altered (e.g., OU names changed), the stored format in the LDAP server configuration will no longer match, causing role membership to fail even though user authentication (which uses a separate base DN and filter) still works. The LDAP server returning all attributes correctly confirms the issue is in the mapping configuration, not in data retrieval.

Exam trap

The trap here is that candidates confuse a missing 'memberOf' attribute with a Group DN format mismatch, but the question explicitly states all attributes are returned correctly, so the issue must be in how ServiceNow constructs the group search filter, not in the data itself.

How to eliminate wrong answers

Option B is wrong because if the base DN for user search had changed, users would not be able to authenticate at all, but the question states users can authenticate. Option C is wrong because the 'Use secure connection' checkbox affects the encryption of the LDAP connection, not the mapping of group DNs to roles; authentication is working, so connectivity is fine. Option D is wrong because the question explicitly states the LDAP server is returning all attributes correctly, which includes the 'memberOf' attribute if it exists; the issue is that the Group DN format in ServiceNow does not match the new schema, not that the attribute is missing.

Full explanation →
116
MCQhard

A company has a business rule on the Task table that runs on 'before' insert. The rule uses current.gotoField('short_description') and current.setValue('short_description', 'Default'). The rule is ordered to run at 500. However, a second business rule on the same table with order 100 also sets the short_description. What will be the final value of short_description?

A.'Default'
B.Both values will be concatenated
C.The value set by the rule at order 100
D.The field will be empty because gotoField() clears it
AnswerA

The rule with order 500 runs last and sets the value to 'Default'.

Why this answer

Business rules execute in ascending order based on their 'order' field. The rule at order 100 runs first and sets the short_description. Then the rule at order 500 runs and overrides that value with 'Default' using current.setValue().

Since both are 'before' insert rules, the final value written to the database is the one set by the last-executed rule, which is order 500.

Exam trap

The trap here is that candidates mistakenly think current.gotoField() clears the field or that rules execute in reverse order, when in fact the rule with the highest order number runs last and its setValue() takes precedence.

How to eliminate wrong answers

Option B is wrong because current.setValue() replaces the field value, it does not concatenate strings. Option C is wrong because although the rule at order 100 sets the value first, the rule at order 500 runs later and overwrites it, so the final value is not from order 100. Option D is wrong because current.gotoField() navigates to the field but does not clear its value; it only makes the field the current focus for scripting, and the subsequent setValue() writes 'Default'.

Full explanation →
117
MCQmedium

The script above fails with HTTP 400 Bad Request. What is the most likely missing configuration?

A.The HTTP method should be PUT instead of POST
B.Missing authentication credentials
C.The Content-Type header is not set to application/json
D.The Accept header should be text/plain
AnswerC

Without Content-Type, the server cannot parse the request body, resulting in 400.

Why this answer

The 400 Bad Request error typically indicates malformed request syntax. A common cause is missing or incorrect Content-Type header. For REST API endpoints expecting JSON payload, the Content-Type header must be set to application/json.

Option C is correct because without this header, the server cannot parse the request body and returns 400. Option A is wrong because the HTTP method (POST) is often correct for creating data; PUT would be for updates. Option B is wrong because missing authentication would result in 401 Unauthorized, not 400.

Option D is wrong because the Accept header controls response format; setting it to text/plain is not required for JSON requests.

Full explanation →
118
MCQhard

Refer to the exhibit. A developer wrote this client script to hide a field when another field changes to '1'. However, the script throws a JavaScript error. What is the most likely cause?

A.hideField is not a valid method; the correct method is setDisplay or setVisible.
B.hideField is a server-side method and cannot be used in client scripts.
C.The developer should use showFieldMsg to hide the field.
D.The function signature is incorrect for an onChange client script.
AnswerA

Correct: g_form.setDisplay('field2', false) or g_form.setVisible('field2', false) should be used.

Why this answer

`hideField` is not a valid client-side method in ServiceNow. The correct methods to control field visibility in client scripts are `setDisplay` (to show/hide a field) or `setVisible` (to show/hide a field and its label). Using an undefined method like `hideField` will throw a JavaScript error because the GlideForm (g_form) API does not include it.

Exam trap

ServiceNow often tests the distinction between valid and invalid g_form methods, and the trap here is that candidates may assume `hideField` is a real method because it sounds intuitive, without knowing the exact API names like `setDisplay` or `setVisible`.

How to eliminate wrong answers

Option B is wrong because `hideField` is not a server-side method either; it is simply not a valid method in ServiceNow at all. Option C is wrong because `showFieldMsg` is used to display informational messages on a field, not to hide it. Option D is wrong because the function signature for an onChange client script is `onChange(controlName, oldValue, newValue, isLoading, isTemplate)` — the error is not caused by an incorrect signature but by calling an undefined method.

Full explanation →
119
MCQeasy

A company needs to create a new application in ServiceNow Studio. What is the correct first step?

A.Navigate to System Applications > Studio and click 'Create Application'.
B.Open Studio from the left navigation menu, then click 'Create Application'.
C.Use the Application Navigator to create a new application.
D.Go to Application Files > New and select 'Application'.
AnswerB

Correct first step in Studio.

Why this answer

The correct first step because ServiceNow Studio is accessed from the left navigation menu, and then clicking 'Create Application' starts the application creation wizard. Option A is incorrect because navigating to System Applications > Studio is not the standard path; Studio is available directly. Option C is incorrect because the Application Navigator is used for navigating existing applications, not creating new ones.

Option D is incorrect because Application Files > New is for creating individual files within an application, not the application itself.

Full explanation →
120
MCQhard

A customer reports that a scheduled data synchronization job takes longer than expected. The job queries the 'cmdb_ci' table and updates records based on an external source. The DBA suggests adding an index on the 'source' field. After adding the index, performance does not improve. What is the most likely reason?

A.The index was not created correctly.
B.The job runs during peak hours.
C.The job uses a condition that filters on a different field.
D.The database is replicated to a secondary site.
AnswerC

Correct: The index on 'source' is not utilized if the query filters on another field.

Why this answer

Indexes only improve performance when the query condition uses the indexed field. If the job filters on a different field, the index on 'source' will not be used.

Full explanation →
121
MCQmedium

A company uses REST API to push data from ServiceNow to an external system. The authentication keeps failing with HTTP 401. They have set up OAuth 2.0 client credentials grant. What is the most likely cause?

A.Missing client ID in the request
B.Wrong token endpoint URL
C.Using HTTP instead of HTTPS
D.Refresh token has expired
AnswerB

If the token endpoint URL is incorrect, the authorization server cannot validate credentials, leading to 401.

Why this answer

In client credentials grant, the token endpoint must be correct. Option A is wrong because missing client ID would cause a different error. Option C is wrong because HTTPS is required but not the most likely cause of 401.

Option D is wrong because client credentials grant does not use refresh tokens.

Full explanation →
122
MCQhard

Refer to the exhibit. What security risk is present in this implementation?

A.The request exposes internal API credentials
B.The endpoint does not require authentication
C.The client exposes the widget to XSS attacks
D.The data is not subject to the same ACLs as server-side calls
AnswerD

Correct: Client-side REST calls may have different ACL behavior than server GlideRecord queries.

Why this answer

Using client-side $http calls bypasses the server-side ACL evaluation that occurs when using spUtil or server scripts. Client-side REST API calls still respect ACLs based on the user's session, but they may expose sensitive data that goes through different security checks. However, a more critical risk is that the endpoint might be susceptible to CSRF if not protected.

In the context of Service Portal, the recommended approach is to use spUtil.get or a server script to ensure proper data access control. Option D highlights the risk of inconsistent ACL enforcement.

Full explanation →
123
MCQeasy

What is the purpose of using the 'Async' option in a business rule?

A.To run the rule immediately after the database operation.
B.To run the rule only when the record is viewed.
C.To prevent the rule from running on updates.
D.To run the rule in a separate background thread to avoid performance impact.
AnswerD

Correct; async rules are queued and run asynchronously.

Why this answer

The 'Async' option in a business rule causes the rule to execute in a separate background thread after the database operation, which avoids performance impact on the main transaction. Therefore, option D is correct. Option A is incorrect because running immediately is the default synchronous behavior, not async.

Option B is incorrect because 'Async' is not related to record viewing; that is controlled by the 'Display' condition. Option C is incorrect because async rules still run on updates; they just run asynchronously.

Full explanation →
124
MCQhard

A senior developer is troubleshooting a performance issue in a Production instance. The instance has a large number of Business Rules that run on the incident table. One particular Business Rule, 'Update CI Impact', runs on the 'After Update' order and performs a GlideRecord query on the cmdb_ci table based on the incident's configuration item (ci) field. The query uses a filter to find all CIs related to the same location as the incident. Recently, users have reported that saving an incident takes over 30 seconds. The developer suspects this Business Rule is the cause. The developer examines the script and finds it uses a synchronous GlideRecord query with no scoping on the query. The developer wants to minimize impact on performance without removing the functionality. Which approach should the developer take?

A.Change the Business Rule to run asynchronously using the 'Async' checkbox in the Business Rule form.
B.Add an index on the cmdb_ci table for the location field and use an efficient query.
C.Move the logic to a scheduled job that runs every hour instead of on every update.
D.Convert the GlideRecord query to use GlideRecordSecure to limit access.
AnswerA

Correct: Async execution prevents blocking the user transaction.

Why this answer

Enabling the 'Async' checkbox on the Business Rule moves the execution to the background job scheduler, allowing the incident save transaction to complete immediately without waiting for the GlideRecord query to finish. This eliminates the synchronous delay that causes the 30-second save time, while preserving the functionality of updating CI impact.

Exam trap

The trap here is that candidates often assume performance issues are always solved by optimizing the query (indexing) rather than recognizing that moving the execution out of the synchronous transaction path is the correct architectural fix for blocking delays.

How to eliminate wrong answers

Option B is wrong because adding an index on the location field in cmdb_ci table improves query performance but does not address the fundamental issue of a synchronous GlideRecord query blocking the transaction; the query still runs synchronously and can cause delays if the dataset is large or the query is complex. Option C is wrong because moving the logic to a scheduled job that runs every hour removes the real-time functionality of updating CI impact immediately upon incident updates, which may not meet business requirements and is not a minimal-impact change. Option D is wrong because converting to GlideRecordSecure does not affect performance; it only enforces ACL-based security on the query, which does not reduce execution time or remove synchronous blocking.

Full explanation →
125
MCQmedium

A developer is asked to add a custom button to the Service Portal form for the 'incident' table. The button should trigger a client script that displays a confirmation dialog before submitting the form. Which approach should the developer use?

A.Create a UI Policy on the incident table with a client script that shows the button conditionally.
B.Create an Access Control Rule (ACL) on the incident table and attach a client script.
C.Create a Business Rule on the incident table that injects a button via server-side code.
D.Create a UI Action on the incident table with a client script and set the 'Show insert' condition.
AnswerD

Correct. UI Actions allow adding custom buttons to forms and attaching client scripts. By setting the 'Show insert' condition appropriately, the button can be displayed on the form and execute a client script that shows a confirmation dialog before submission.

Why this answer

UI Actions in Service Portal are the standard mechanism for adding custom buttons to forms. By creating a UI Action on the incident table with a client script, the developer can add a button that triggers a confirmation dialog before form submission. UI Policies only control field attributes (e.g., visibility, mandatory) and cannot create new UI elements like buttons.

Exam trap

A common mistake is to assume UI Policies can add custom buttons because they control client-side behavior. However, UI Policies only modify existing field properties; they cannot inject new UI elements. UI Actions are specifically designed for adding buttons and attaching client scripts to them.

How to eliminate wrong answers

Option B is wrong because Access Control Rules (ACLs) control data access and security, not UI element visibility or client-side button behavior; attaching a client script to an ACL is not a supported pattern for adding buttons. Option C is wrong because Business Rules run server-side and cannot directly inject buttons into the Service Portal UI; they are used for server-side logic like data validation or automation, not client-side UI manipulation. Option D is wrong because UI Actions in Service Portal are used to add buttons to form headers or lists, but the 'Show insert' condition controls when the button appears based on the form mode (insert vs. update), not for triggering a client-side confirmation dialog before submission; UI Actions with client scripts can show dialogs, but the condition described is irrelevant to the requirement.

Full explanation →
126
MCQhard

A developer has a GlideRecord query that retrieves 10,000 records. They need to perform an update on each record. Which approach is most efficient to avoid performance issues?

A.Use GlideRecord's batch mode without any modifications.
B.Use setWorkflow(false) and setAutoSysFields(false) before updating each record.
C.Use multiple GlideRecord queries to process records in batches.
D.Use setLimit(100) and run the script multiple times.
AnswerB

Disabling workflow and auto sys fields reduces overhead.

Why this answer

Using `setWorkflow(false)` disables business rules and `setAutoSysFields(false)` prevents automatic updates of system fields (like `sys_updated_by` and `sys_updated_on`), significantly reducing database write overhead and improving performance when updating many records. Option A is wrong because GlideRecord's batch mode alone does not disable workflows or system fields; business rules still execute. Option C is wrong because using multiple queries increases the number of database operations and overall load.

Option D is wrong because `setLimit(100)` restricts the query to only 100 records, so updates would miss the remaining 9,900 records.

Full explanation →
127
MCQeasy

A user needs to generate a report that shows the count of incidents by category for the current month. Which table and field combination should be used in a report?

A.Use the 'cmdb_ci' table with 'install_status' and 'sys_created_on'.
B.Use the 'task' table with 'priority' and 'sys_updated_on'.
C.Use the 'sys_user' table with 'department' and 'sys_created_on'.
D.Use the 'incident' table with 'category' and 'sys_created_on'.
AnswerD

Correct: Incident table is relevant and category field provides grouping.

Why this answer

The incident table contains incident records, and the category field allows grouping incidents by category, while sys_created_on can be used to filter incidents created in the current month. Option A is incorrect because the cmdb_ci table is for configuration items, not incidents. Option B is incorrect because the task table includes multiple task types (incidents, problems, changes), so it's not specific to incidents.

Option C is incorrect because the sys_user table stores user information, not incidents.

Full explanation →
128
Multi-Selecteasy

Which TWO of the following are valid types of client scripts in ServiceNow? (Choose two.)

Select 2 answers
A.onDelete
B.onSubmit
C.onChange
D.onClick
E.onUpdate
AnswersB, C

onSubmit client scripts run when the form is submitted.

Why this answer

In ServiceNow, the valid client script types are onChange, onSubmit, onLoad, and onCellEdit. Among the given options, onSubmit (B) and onChange (C) are standard client script types. onDelete, onClick, and onUpdate are not valid client script types in ServiceNow.

Full explanation →
129
MCQeasy

A Service Portal widget displays a list of open incidents. The data is updated via a GlideAjax call in the client controller. Users report that the list does not refresh automatically when a new incident is created. The developer wants to implement auto-refresh without manual page reload. The widget is used on a dashboard that does not require real-time updates every second. Which approach is most efficient?

A.Use Angular $interval to call the GlideAjax every 30 seconds in the client controller
B.Set up a real-time data channel using WebSocket and push updates from server
C.Use the 'spNavigation' API to reload the entire page every 30 seconds
D.Trigger the GlideAjax call on mouseover and focus events
AnswerA

Efficient polling mechanism that updates the data without reloading the page.

Why this answer

Using a polling interval (e.g., 30 seconds) strikes a balance between data freshness and server load. Option B is unnecessary since real-time updates are not required. Option C is inefficient due to full page reload.

Option D misses updates when the user is not interacting.

Full explanation →
130
MCQmedium

A reference field on a form shows a list of records, but the user cannot see any results when typing. The reference qualifier is set to 'active=true'. What is the most likely cause?

A.The user does not have read access to the referenced table.
B.There are no records that satisfy the reference qualifier condition.
C.The field is read-only and prevents searching.
D.The field's dictionary entry does not have a reference table specified.
AnswerB

A restrictive reference qualifier can result in an empty list.

Why this answer

If the reference qualifier condition 'active=true' filters out all records (e.g., all records are inactive), no results appear. Option A is incorrect: lack of read access would prevent the user from seeing any records at all, but the user can see the field and type. Option C is incorrect: a read-only field prevents editing but does not affect searching for new records.

Option D is incorrect: if no reference table were specified, the field would not function; the problem is the qualifier filtering.

Full explanation →
131
MCQmedium

A developer sees the above error in the browser console when an incident form loads. What is the most likely cause?

A.The onLoad client script is running on the server instead of the client.
B.The onLoad client script uses GlideRecord, which is not available client-side.
C.The script uses a typo: 'GlideRecord' should be 'GlideRecord'.
D.GlideRecord has been deprecated and replaced by a newer API.
AnswerB

Client scripts must use GlideAjax to call server-side GlideRecord.

Why this answer

The onLoad client script runs on the client side, where GlideRecord is not available. Using it directly in a client script causes the 'gliderecord is not defined' error. Option A is wrong because server-side scripts can use GlideRecord without error.

Option C is wrong because 'GlideRecord' is spelled correctly. Option D is wrong because GlideRecord is not deprecated.

Full explanation →
132
Multi-Selecteasy

A developer is creating a business rule that should run on after update of the Incident table. The developer wants to ensure the rule only fires when the incident is assigned to a specific assignment group. Which conditions should be used in the business rule's condition field? (Choose two.)

Select 2 answers
A.current.operation() == 'update'
B.current.assignment_group.isValidRecord()
C.current.assignment_group == 'IT Support'
D.current.assignment_group.changes()
E.gs.getUser().getManager() == 'admin'
AnswersA, C

This ensures the rule only runs on update.

Why this answer

`current.operation() == 'update'` ensures the business rule only runs during an update operation on the Incident table. This is the standard way to check the database operation type in ServiceNow business rules, matching the requirement that the rule should fire 'on after update'.

Exam trap

The trap here is that candidates often confuse `current.assignment_group.changes()` with a condition that checks the current value, when in fact it only detects a change event, not the actual group assignment.

Full explanation →
133
MCQhard

A ServiceNow instance has a business rule that runs on after query on the Incident table. The rule adds a condition to the query to filter out incidents with state = 'Closed'. Recently, an update set containing a new business rule was installed, and now the filter is not applied. What might have caused this?

A.The new business rule has a higher order than the existing rule
B.The existing business rule is set to run only on insert
C.The new business rule uses query.setCondition() to set the query condition, replacing the existing condition
D.The new business rule uses glide.addNullQuery
AnswerC

setCondition() overwrites any previous conditions.

Why this answer

The new business rule likely uses query.setCondition() which replaces any existing conditions, including the filter from the existing rule. Option A is less likely because order determines execution sequence, but setCondition replaces. Option B is incorrect.

Option D is irrelevant.

Full explanation →
134
MCQhard

A ServiceNow instance integrates with an external inventory system via a scheduled REST import job. Recently, the import started failing intermittently with HTTP 429 (Too Many Requests) errors. The external system enforces a rate limit of 100 requests per minute. The existing job pulls 1500 records at a time using a single REST message. Which design change would best resolve this issue while ensuring the import completes successfully?

A.Reduce the batch size to 50 records and add a 1-second delay between consecutive REST calls
B.Increase the number of threads in the import set table loader to process records faster
C.Increase the batch size to 5000 records per request to reduce the number of calls
D.Switch the REST message to use Basic Authentication instead of OAuth to reduce overhead
AnswerA

This stays within the 100 requests/min limit (50 requests with 1s delay = 50 requests/min) and ensures all data is imported.

Why this answer

Reducing the batch size to 50 records ensures that each REST call stays within the external system's rate limit of 100 requests per minute. Adding a 1-second delay between consecutive calls further prevents bursts that could trigger HTTP 429 errors, while still allowing the import to complete by making multiple smaller requests over time.

Exam trap

The trap here is that candidates often assume increasing batch size or thread count will improve throughput, but in rate-limited scenarios, reducing concurrency and pacing requests is the correct approach to avoid HTTP 429 errors.

How to eliminate wrong answers

Option B is wrong because increasing the number of threads in the import set table loader would increase concurrency, potentially sending more requests simultaneously and worsening the rate-limit issue. Option C is wrong because increasing the batch size to 5000 records per request would likely exceed the external system's payload limits or timeout thresholds, and does not address the rate limit of 100 requests per minute. Option D is wrong because switching from OAuth to Basic Authentication does not reduce the number of requests or the rate at which they are sent; authentication method has no impact on HTTP 429 errors caused by rate limiting.

Full explanation →
135
MCQmedium

You are a ServiceNow administrator for a large organization that uses a custom application to manage IT assets. The application has a business rule on the 'asset' table that runs 'after update' and logs changes to a separate audit table. Recently, users have reported that saving an asset record takes over 30 seconds, and the system performance has degraded. Upon investigation, you find that the business rule contains a GlideRecord query that retrieves all related asset history records for each update, and then performs additional calculations. The asset table has over 500,000 records, and each asset has an average of 50 history records. The business rule is triggered on every field update, including minor changes like last modified date. You need to improve the response time without losing the audit functionality. Which course of action should you take?

A.Change the business rule to run 'before' update to perform the audit logging earlier in the process.
B.Add a condition to the business rule so that it only executes when specific important fields (e.g., status, assigned to) are changed.
C.Delete the business rule and implement the audit logic using a script include called from a UI policy.
D.Change the business rule to run asynchronously by selecting 'Run asynchronously' in the advanced view.
AnswerB

This reduces the number of times the resource-intensive code runs, improving performance while still logging critical changes.

Why this answer

Adding a condition to limit execution to only significant changes (e.g., important fields) reduces the frequency of the heavy operation. Option A is not valid because before business rules cannot write to a different table after the operation; they would need to use a separate script. Option C is incorrect because implementing the audit logic using a script include called from a UI policy is not suitable; UI policies are client-side and cannot perform server-side operations like writing to an audit table.

Option D might cause delays if asynchronous execution is not properly configured, and it still runs the same operation; additionally, asynchronous business rules can lead to data consistency issues.

Full explanation →
136
MCQhard

A Service Portal widget is failing to update a reference field on a form after a user selects a value from a reference picker. The developer reviews the widget's client controller and sees the following code snippet: $scope.c.data.selectedItem = value; The server script expects 'selectedItem' to be a sys_id string, but it is receiving an object. What is the most likely cause?

A.The server script expects the parameter in a different scope variable, like $scope.c.data.item.
B.The $scope.c.data assignment is incorrect; it should be $scope.data.
C.The client controller is not allowed to set $scope.c variables.
D.The reference field returns an object with 'value' and 'display' properties; the code should extract the sys_id.
AnswerD

Reference fields return an object; the sys_id is typically in value or sys_id property.

Why this answer

When a reference picker returns a value in Service Portal, it typically provides an object containing both the display value and the sys_id (e.g., {value: 'sys_id', display: 'name'}). The client controller code assigns this entire object to $scope.c.data.selectedItem, but the server script expects a plain sys_id string. The developer must extract the sys_id property (e.g., value.sys_id or value.value) before assigning it to the scope variable.

Exam trap

The trap here is that candidates assume the reference picker returns a simple string (the sys_id) and overlook that Service Portal reference fields return an object with both value and display properties, leading them to choose options about scope naming or assignment syntax instead of the data format mismatch.

How to eliminate wrong answers

Option A is wrong because the issue is not about the scope variable name; the server script correctly expects 'selectedItem', but it receives an object instead of a string. Option B is wrong because $scope.c.data is the correct way to access data in a Service Portal widget's client controller; $scope.data is not used in this context. Option C is wrong because client controllers are fully allowed to set $scope.c variables; this is the standard pattern for passing data to the server script via $scope.c.data.

Full explanation →
137
MCQhard

A developer needs to ensure that when a Configuration Item record is deleted, all related Incident records have their CI field set to empty. Which approach should be taken?

A.Set the reference field's 'Delete action' to 'Cascade'.
B.Use a workflow on the CI table to update related incidents.
C.Create a business rule on the CI table that updates incidents on delete.
D.Use a database trigger on the CI table.
AnswerC

A before delete business rule can iterate related incidents and clear the CI field.

Why this answer

A business rule on the CI table with a 'before delete' or 'after delete' condition can query all incident records referencing the deleted CI and set the CI field to empty/null. Option A ('cascade') would delete the related incidents instead of clearing the CI field. Option B (workflow) is unnecessarily complex; a business rule is more efficient and direct.

Option D (database trigger) is not supported in ServiceNow.

Full explanation →
138
Multi-Selecteasy

Which TWO accessibility considerations are essential when designing for Service Portal? (Choose two.)

Select 2 answers
A.Use of color alone for important information
B.Complex data tables without headers
C.Auto-play videos
D.Proper heading structure
E.Keyboard navigation support
AnswersD, E

Correct: Headings help screen readers navigate content.

Why this answer

Proper heading structure and keyboard navigation are essential for accessibility. Color alone should not convey information, and auto-play videos can be a barrier. Complex data tables can be made accessible but require proper markup.

Full explanation →
139
MCQmedium

A company wants to synchronize user data from an external HR system into ServiceNow every night. The HR system pushes a CSV file to an SFTP server. Which ServiceNow feature should be used to automate this process?

A.External Data Source
B.SOAP Web Service
C.REST API
D.Scheduled Import
AnswerD

Correct: Scheduled Import can be configured to pull files from SFTP and import them into import sets.

Why this answer

Scheduled Import from an SFTP server is the proper feature to automate ingestion of files from an external SFTP location at scheduled intervals.

Full explanation →
140
MCQmedium

A developer is working on a new application and wants to ensure all changes are tracked for deployment. The developer creates a new application in Studio and makes modifications. When the developer tries to create an update set, the application changes are not captured. The developer checks the application properties and sees the 'Update Set' field is set to 'Default'. The developer is in a scoped application. What is a possible reason?

A.The application is marked as 'Not in an update set'.
B.The application's scope is set to 'Global'.
C.The application is in a different phase.
D.The developer has not set the 'Update Set' field on the application.
AnswerD

Correct. The developer has not changed the 'Update Set' field from 'Default' to a specific update set, so changes are captured in the default update set rather than the new one.

Why this answer

The application's 'Update Set' field is set to 'Default', which means changes are captured in the session's default update set. However, since the developer is creating a new update set, the changes are not automatically captured in the new update set. The developer must explicitly set the application's 'Update Set' field to the newly created update set to capture changes there.

Option D is correct because the developer has not set this field to a specific update set, so changes continue to go to 'Default'. Options A, B, and C are incorrect: A is false because the field shows 'Default', not 'Not in an update set'; B is false because the application is scoped; C is false because phase does not affect update set capture.

Full explanation →
141
Multi-Selectmedium

Which TWO actions should a developer take when designing an inbound email integration in ServiceNow to ensure proper data mapping? (Choose two.)

Select 2 answers
A.Set up an ACL to allow the email user to write to the target table
B.Ensure the email includes an attachment with the data
C.Configure the inbound email action to trigger on the appropriate table
D.Create a connection to the external email server
E.Use the email parsing script to extract fields from the email body
AnswersC, E

The inbound action must be associated with the table where records will be created or updated.

Why this answer

Inbound email actions in ServiceNow are configured to trigger on a specific target table, which defines where the incoming email data will be mapped and stored. This ensures that the email processing logic is applied to the correct table, enabling proper data mapping and field extraction.

Exam trap

The trap here is that candidates often confuse the inbound email action table configuration with ACLs or email server connections, thinking those are required for data mapping, when in fact the table selection and parsing script are the core mechanisms for mapping email data to ServiceNow records.

Full explanation →
142
MCQmedium

A company uses a scoped application to manage IT equipment. The application has a client script that calls a GlideRecord query on a large table. Recently, the script started showing 'Script exceeded maximum execution time' errors. The developer checks the Studio debugger and sees the query runs on the entire table without filters. The developer needs to fix this issue. The environment is production, and downtime must be minimized. Which course of action should the developer take?

A.Move the query to a Business Rule and use a client-callable API.
B.Increase the script execution timeout in system properties.
C.Use GlideAggregate with multiple queries.
D.Add an index on the table.
AnswerA

Correct. Offloading to server-side solves the timeout and improves performance.

Why this answer

Moving the query to a Business Rule and using a client-callable API (like GlideAjax) offloads the heavy processing to the server side, avoiding client-side timeouts. Option B is incorrect because increasing the script execution timeout only delays the issue and does not fix the root cause of the query running without filters. Option C is incorrect because GlideAggregate is used for aggregation functions like count, sum, etc., not for retrieving records; the problem is an unfiltered query, not aggregation.

Option D is incorrect because adding an index helps with performance for filtered queries, but if the query has no filters, an index does not help as it still needs to scan the entire table.

Full explanation →
143
Matchingmedium

Match each ServiceNow update set state to its meaning.

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

Concepts
Matches

Update set is being worked on

All changes have been captured and committed locally

Update set has been applied to the target instance

Update set will not be committed

Update set is being tested for conflicts

Why these pairings

Update set states control the lifecycle of change tracking. 'In progress' indicates active work, 'Complete' indicates all changes are added, 'Committed' indicates the set is applied to an instance, and 'Submitted' indicates it is sent for review. Common confusions include swapping 'In progress' and 'Complete' definitions.

Full explanation →
144
MCQmedium

A knowledge base article template needs a new custom field for 'Article Version'. The administrator wants to add this field to the template so it appears on all articles using that template. What is the correct approach?

A.Modify the existing template to include the new field.
B.Create a new template with the field and re-assign all articles.
C.Use a UI Policy to show the field on articles using that template.
D.Add the field globally to the Knowledge base application file.
AnswerA

Templates define the layout, so adding the field to the template propagates to articles.

Why this answer

Knowledge base templates define the fields that appear on articles. Adding the field to the template ensures it appears on all articles using that template.

Full explanation →
145
MCQeasy

The data policy is intended to require short description when category changes during an update. However, the short description is never made mandatory. Which issue exists?

A.The table is Incident but the policy uses current.operation() incorrectly
B.The condition should use AND instead of OR
C.The script uses setMandatory which is not available in Data Policies
D.The policy should be of type 'Constraint'
AnswerC

Correct; Data Policies cannot change field properties via script; they can only enforce validation or abort saves.

Why this answer

`setMandatory()` is a client-side method used in client scripts or UI policies, not in data policies. Data policies run server-side and use `mandatory=true` on a dictionary element or `gs.addErrorMessage()` to enforce field requirements. Since the script attempts to call `setMandatory()` within a data policy, it will fail to make the short description mandatory, leaving the requirement unmet.

Exam trap

ServiceNow often tests the distinction between server-side and client-side APIs, and the trap here is that candidates assume `setMandatory()` works everywhere because it is commonly used in UI policies, but it is not available in data policies.

How to eliminate wrong answers

Option A is wrong because `current.operation()` is a valid method in data policies to check the current database operation (insert, update, delete), and using it on the Incident table is appropriate; the issue is not about incorrect usage of this method. Option B is wrong because the condition logic (AND vs OR) is not the core problem; even with correct condition syntax, the script would still fail due to the invalid `setMandatory()` call. Option D is wrong because a 'Constraint' type policy is used for enforcing referential integrity or validation rules, not for making fields mandatory; the policy type 'Normal' is correct for this requirement.

Full explanation →
146
Multi-Selecthard

A developer is experiencing an issue where a client script is not executing in a scoped application. Which TWO of the following could be causing the issue?

Select 2 answers
A.The script has a syntax error.
B.The script is in the global scope but the application is scoped.
C.The user does not have the 'client_script_admin' role.
D.The script's 'Condition' is set to 'true'.
E.The script is using a global variable.
AnswersA, B

Will prevent execution.

Why this answer

Options A and B are correct. A syntax error (A) prevents the client script from executing. If the script is defined in the global scope but the application is scoped (B), the script may not be accessible due to ServiceNow scoping rules, causing it to not execute.

Option C is incorrect because the 'client_script_admin' role is not required for client scripts to run; roles affect administrative access to script records, not execution. Option D is incorrect because setting the condition to 'true' would cause the script to always execute, not prevent it. Option E is incorrect because using a global variable in a client script is allowed and does not prevent execution.

Full explanation →
147
MCQeasy

Which method should be used to delete all records in the 'incident' table where the state is 'Closed' and the sys_updated_on is older than 90 days?

A.GlideRecord.deleteMultiple()
B.GlideAggregate.deleteMultiple()
C.GlideRecord.deleteRecord()
D.GlideRecord.setDelete(true)
AnswerA

Correct: deleteMultiple() deletes all records matching the query.

Why this answer

GlideRecord.deleteMultiple() is the appropriate method to delete multiple records that match a specified query, such as all incidents in 'Closed' state updated over 90 days ago. Option B is incorrect because GlideAggregate is used for aggregation (e.g., counting, summing) and does not have a deleteMultiple() method. Option C is incorrect because GlideRecord.deleteRecord() only deletes the current single record (the one loaded into the GlideRecord object).

Option D is incorrect because GlideRecord.setDelete(true) is not a valid method; deletion is performed via deleteRecord() or deleteMultiple().

Full explanation →
148
MCQhard

A developer is troubleshooting a Service Portal widget that loads slowly. The widget uses a server script that queries a large table without any filters. Which design change would most improve performance?

A.Add client-side caching using $scope
B.Load the widget using ng-if instead of ng-show
C.Create a custom table with only required fields
D.Add a filter condition in the GlideRecord query
AnswerD

Filtering reduces the result set, improving query performance.

Why this answer

Adding a filter condition to the GlideRecord query reduces the dataset retrieved from the database, minimizing network transfer and server-side processing time. Without filters, the query returns all rows from a large table, causing excessive load on the instance and slow widget rendering. Filtering at the database level is the most efficient way to improve performance in Service Portal widgets.

Exam trap

The trap here is that candidates confuse client-side optimizations (caching, DOM manipulation) with server-side data retrieval improvements, overlooking that the root cause is an unfiltered database query that must be addressed at the source.

How to eliminate wrong answers

Option A is wrong because client-side caching using $scope stores data in the browser's memory but does not reduce the initial server query that retrieves the entire unfiltered table, so the slow load persists on first access. Option B is wrong because ng-if and ng-show control DOM rendering, not data retrieval; ng-if removes elements from the DOM when false, but the widget's server script still runs and fetches all records regardless. Option C is wrong because creating a custom table with only required fields is a schema change that requires manual maintenance and does not address the immediate issue of querying the large table without filters; it also violates the principle of minimizing data retrieval at query time.

Full explanation →
149
MCQeasy

Refer to the exhibit. A transform map configuration is shown. What will happen if the source data has a 'u_model_id' value that matches an existing record in the 'cmdb_ci_model' table?

A.The transform will ignore the field because it is already mapped.
B.The transform will create a new model record with the given value.
C.The transform will automatically set the model_id reference to the existing model record.
D.The transform will skip the record because the model already exists.
AnswerC

Coalesce uses the source value to match a record in the referenced table and sets the reference.

Why this answer

When coalesce is set to true on a reference field like 'model_id', the transform engine uses the source value (u_model_id) to look up an existing record in the referenced table (cmdb_ci_model). If a matching record is found, the transform sets the reference field to that existing record without creating a new one. Option A is incorrect because coalesce does not ignore the field; it actively searches for a matching record.

Option B is incorrect because coalesce does not create new records; it only matches existing ones. Option D is incorrect because the transform does not skip the record; it proceeds with the transformation, setting the reference to the existing model.

Full explanation →
150
MCQhard

A large enterprise has multiple scoped applications that share common code. The developer created a shared application as a dependency. However, when updating the shared application, some dependent applications break. The developer needs to manage updates to the shared application without causing disruptions. The environment is under change control and requires approval for any deployment. Which approach is the best practice?

A.Use Semantic Versioning and test before update.
B.Create a separate update set for each dependent application.
C.Use update sets to track changes to the shared application.
D.Avoid shared dependencies and duplicate code in each application.
AnswerA

Correct. Semantic Versioning helps manage breaking changes.

Why this answer

Semantic Versioning allows developers to communicate the nature of changes (major, minor, patch) and test the shared application before updating dependencies, minimizing disruptions. Option B is wrong because creating separate update sets for each dependent application does not address version compatibility or testing. Option C is wrong because using update sets to track changes alone does not manage version compatibility or prevent breaks.

Option D is wrong because avoiding shared dependencies leads to code duplication and maintenance overhead, which is not a best practice.

Full explanation →
Page 1

Page 2 of 7

Page 3

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 →