Courseiva

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

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

Take a mock examExam hub
Page 1

Page 2 of 7

Page 3
76
MCQmedium

An application scope includes a Business Rule that runs on the 'before' operation of the Incident table. It attempts to set the 'assignment_group' based on the caller's company. However, the assignment is not being applied. Which is the most likely cause?

A.The Business Rule is set to 'async' which delays execution
B.The script uses 'current.assignment_group = something' without calling setValue
C.The Business Rule is set to run on 'display' instead of 'update'
D.The field 'assignment_group' is not in the current scope's accessible table columns due to cross-scope privilege
AnswerD

Correct; if the Business Rule is in a scoped application and the Incident table belongs to the global scope, the scoped app may not have write access to the field unless an access grant is defined.

Why this answer

Option D is correct because in ServiceNow, cross-scope privilege restrictions prevent a scoped application from accessing or modifying columns in the Incident table that are not explicitly granted via the application's scope. Even though the Business Rule runs on the 'before' operation, if the 'assignment_group' field is not in the application's accessible table columns, the assignment will silently fail. This is a common issue when a scoped application attempts to interact with global table fields without proper cross-scope access.

Exam trap

The trap here is that candidates often assume the issue is a scripting syntax error (like Option B) or a timing problem (like Option A), but ServiceNow's cross-scope security model silently blocks field writes without explicit privilege, making it the most likely cause when a scoped application's Business Rule fails to update a global field.

How to eliminate wrong answers

Option A is wrong because setting a Business Rule to 'async' delays execution to a background queue, but it does not prevent the assignment from being applied; the assignment would still occur asynchronously. Option B is wrong because using 'current.assignment_group = something' is a valid way to set a field value in a 'before' Business Rule, as it directly modifies the current record in memory without needing setValue. Option C is wrong because a Business Rule set to run on 'display' only triggers when the record is viewed, not on update, so it would not affect the assignment during an update operation; however, the question states the rule runs on 'before' operation, so this is not the issue.

Full explanation →
77
MCQhard

A developer is implementing a custom integration using the ServiceNow REST API Explorer. The endpoint requires an API key in the header. Which approach should be used to secure the API key?

A.Create an authentication profile of type 'API Key' and reference it in the REST message.
B.Hardcode the API key in the script.
C.Store the API key in a system property encrypted.
D.Use a REST message variable and set the header directly.
AnswerA

Auth profiles securely store credentials and can be referenced without exposing the key.

Why this answer

Option A is correct because the ServiceNow REST API Explorer and REST messages support authentication profiles, which securely store and manage API keys. By creating an 'API Key' authentication profile and referencing it in the REST message, the API key is automatically injected into the request header without exposing it in scripts or system properties. This approach follows ServiceNow best practices for credential management and ensures the key is encrypted and centrally managed.

Exam trap

The trap here is that candidates may think storing the API key in an encrypted system property (Option C) is sufficient, but they overlook that the key still needs to be retrieved and injected into the header via script, which is less secure and not the recommended ServiceNow pattern for REST message integrations.

How to eliminate wrong answers

Option B is wrong because hardcoding the API key in a script exposes it in plain text within the application code, violating security best practices and making it difficult to rotate or audit. Option C is wrong because storing the API key in an encrypted system property still requires the script to retrieve and inject it into the header manually, which is less secure and more error-prone than using a dedicated authentication profile. Option D is wrong because using a REST message variable and setting the header directly in the script bypasses the built-in authentication profile framework, leading to potential exposure of the key in script logs or code reviews.

Full explanation →
78
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 →
79
Multi-Selecthard

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

Select 3 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, E

Correct: Dot-walking uses the same query if the reference is already loaded.

Why this answer

Options B, D, and E are correct. Using sets, dot-walking, and GlideAggregate all reduce queries. Option A is wrong because separate queries increase queries.

Option C is wrong because getValue does not reduce queries.

Full explanation →
80
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

Option A is correct: addAggregate('COUNT', 'sys_id') counts rows. Option B is wrong because addAggregate requires a field name. Option C is wrong because 'count' is not a valid function.

Option D is wrong because it specifies a field but function name is missing.

Full explanation →
81
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

Option C is correct because when a child table inherits fields from a parent, the form layout must be configured to display them; often the child table form layout is separate and may not include all parent fields. Option A is unlikely because ACLs would affect visibility but usually not hide fields without explicit reason. Option B is irrelevant because mandatory does not affect visibility.

Option D is false because manufacturer exists on cmdb_ci.

Full explanation →
82
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, B, and E are correct: Business Rules, UI Macros, and ACLs can be created in Studio. Reports are created in Reports module. Flows are created in Flow Designer.

Full explanation →
83
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 →
84
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 →
85
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

Option B is correct because for duplicate detection to work properly, the import set table must have a unique index on the coalesce field. Without it, the system cannot detect duplicates within the same import set, leading to multiple rows being inserted into the target. Option A is incorrect because the mapping is likely correct if coalesce is set.

Option C is incorrect because the checkbox is checked. Option D is incorrect because the source data has unique asset_tag values, so case mismatch is not the issue.

Full explanation →
86
MCQeasy

The exhibit shows a business rule script snippet. The business rule is triggered on 'before update' of incident table. When an incident's state is changed to 2 (Resolved), the short_description is set to 'Resolved'. However, the short_description is also being set to 'Resolved' when the state is already 2 and other fields are updated. Which change to the script would fix this issue?

A.Change the trigger order from 'before' to 'after'.
B.Change 'current.state == 2' to 'current.state.changesTo(2)'.
C.Remove the condition and let the script run always.
D.Change 'current.state == 2' to 'current.state.changes() && current.state == 2'.
AnswerB, D

changesTo() detects a change to a specific value.

Why this answer

Option B is correct because `current.state.changesTo(2)` is a GlideRecord method that returns true only when the `state` field is being changed *to* the value 2 during the current update. This ensures the short_description is set to 'Resolved' only when the state transitions to 2, not when other fields are updated while the state is already 2. The original script used `current.state == 2`, which evaluates to true whenever the state is 2, regardless of whether it just changed.

Exam trap

The trap here is that candidates often confuse `current.state == 2` (a static value check) with `current.state.changesTo(2)` (a transition check), leading them to pick Option D because they think `changes()` combined with `==` is equivalent, but it fails when the field is updated to the same value.

How to eliminate wrong answers

Option A is wrong because changing the trigger order from 'before' to 'after' does not address the condition logic; it would still evaluate `current.state == 2` and set the short_description on every update where state is 2. Option C is wrong because removing the condition would cause the short_description to be set to 'Resolved' on every update of the incident, regardless of state value, which is not the desired behavior. Option D is wrong because `current.state.changes()` returns true if the state field has changed to any value, and combined with `current.state == 2`, it would still set the short_description when state changes from 2 to 2 (if the field is touched), which does not fix the issue; only `changesTo(2)` correctly isolates the transition to value 2.

Full explanation →
87
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 →
88
MCQhard

A developer runs a GlideAggregate to count the number of incidents per category. The query returns unexpected results: some categories show zero counts but should have incidents. What is the most likely cause?

A.The developer used addAggregate('COUNT', 'category') instead of addAggregate('COUNT').
B.The developer must use addQuery('active', true) to include only active incidents.
C.The developer forgot to call the query() method after grouping.
D.The GlideAggregate cannot handle null values in the grouped field.
AnswerC

Without query(), no records are processed.

Why this answer

Option C is correct because if the query is not started properly (missing query() call), no results are returned. Option A is wrong because GlideAggregate can handle null categories. Option B is wrong because addAggregate('COUNT') is correct.

Option D is wrong because GlideAggregate does not require addQuery for counts.

Full explanation →
89
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

Option C is correct because `$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 →
90
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

Option B is correct because 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 →
91
MCQmedium

A service desk manager wants to create a report that shows the number of incidents assigned to each support group over the past month. The manager wants the report to update automatically every week and be emailed to the team leads. The developer needs to implement this efficiently without creating custom tables or scheduled jobs. Which approach should the developer take?

A.Create a database view that aggregates the data and schedule a data export.
B.Create a scheduled job that runs a report and emails the results.
C.Create a report using the 'Report' module and schedule it to run weekly with email delivery.
D.Create a transform map to import the incident data into a custom table and then report.
AnswerC

Correct: The Report module allows scheduling and emailing of reports directly, meeting all requirements efficiently.

Why this answer

Option C is correct because ServiceNow reports can be scheduled to run at specific intervals and automatically emailed to recipients. This is the standard, built-in functionality that meets the requirements without additional complexity. Option A is a workaround but adds unnecessary overhead.

Option B creates a database view, but scheduling a data export is not the intended use. Option D involves creating custom tables and transforms, which is overkill and not efficient.

Full explanation →
92
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

Option B is correct because 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 →
93
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, D, and E are correct. Using a staging table is a best practice to validate data before transform. Mapping all fields reduces errors.

Setting coalese ensures duplicates are handled. Option B is wrong because skipping transform map creation would bypass transforms. Option C is wrong because direct mapping to target table without transform is not standard; transforms allow data manipulation.

Full explanation →
94
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

Option C is correct because 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 →
95
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 →
96
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 →
97
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 →
98
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 →
99
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

Option C is correct because 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 →
100
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

Option D is correct because 'Create access' property on the table allows specifying roles that can create records. Option A is wrong because 'Abbreviated table' is for naming. Option B is wrong because 'Effective access' is a legacy property.

Option C is wrong because 'Allow attachment' controls file attachments.

Full explanation →
101
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 →
102
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

Option C is correct because 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 →
103
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

Option C is correct because a UI policy can conditionally set the values of a choice field on the client side. Option A (data policy) is server-side and cannot dynamically change choices. Option B (client script) can accomplish this but UI policy is the standard declarative approach.

Option D (reference qualifier) is for reference fields, not choice fields.

Full explanation →
104
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 A and C are correct. Using GlideAjax for server-side and limiting results are best practices. Option B is wrong because synchronous calls are blocking.

Option D is wrong because business rules should be avoided for client scripts. Option E is wrong because GlideRecord is not available in client scripts directly.

Full explanation →
105
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

Option C is correct because 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 →
106
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

Option C is correct because Condition with state=Closed and days since closed > 30, and abort action when field is updated ensures updates are prevented. Option A only sets field read-only when state changes to Closed, not after 30 days. Option B on query does not prevent updates.

Option D UI Policy is client-side only.

Full explanation →
107
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

Options A and C are correct: clicking 'Create Application' and cloning an existing application are valid. Option B is importing, not creating. Option D is not a method.

Option E is not a Studio feature.

Full explanation →
108
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 →
109
MCQeasy

A developer needs to add a custom button to the incident form that executes a script when clicked. Which mechanism should be used?

A.Write a client script that adds a button dynamically.
B.Modify the form layout to include a button widget.
C.Create a UI Action.
D.Configure a UI Policy.
AnswerC

UI Actions are the standard way to add buttons with server-side actions.

Why this answer

Option A is correct because UI Actions define custom buttons that appear on forms and run server-side scripts. Option B is wrong because UI Policies control field behavior, not buttons. Option C is wrong because client scripts run on events but do not create buttons.

Option D is wrong because form layout arranges fields, not buttons.

Full explanation →
110
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 →
111
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

Option B is correct because a data policy can enforce field requirements on server-side updates. Option A (business rule) could also work but data policies are specifically designed for field-level validation. Option C (client script) is client-side only.

Option D (UI policy) is client-side and can be bypassed.

Full explanation →
112
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

Option D is correct because 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 →
113
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

Option D is correct because 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 →
114
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

Option D is correct because 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 →
115
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

Option A is correct because the 'Reference display field' attribute on the dictionary entry specifies which field from the referenced table to display. Option B is wrong because 'Display' field on the referenced table controls the default display of records. Option C is wrong because 'Reference qual' filters available records.

Option D is wrong because 'Default value' sets a default.

Full explanation →
116
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

Option A is correct. The script retrieves the incident with number 'INC001234', sets its state to 2, and updates the record. Option B would require deleteRecord(), C would require insert(), and D is false because get returns true if found.

Full explanation →
117
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

Option A is correct: HTTP 401 with Bearer token indicates the token is invalid or expired. Option B is wrong because wrong endpoint would give 404, not 401. Option C is wrong because missing Content-Type would not cause 401.

Option D is wrong because timeout would be a different error.

Full explanation →
118
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

The correct answer is A because 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 →
119
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

Option A is correct because 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 →
120
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 →
121
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 correct answer is A because 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 →
122
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

Option A is correct because 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 →
123
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

Option A is correct: missing Content-Type header set to application/json causes 400. Option B is wrong because method is POST, which is correct. Option C is wrong because Accept header is set.

Option D is wrong because authentication would cause 401, not 400.

Full explanation →
124
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

Option A is correct because `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 →
125
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

Option A is correct because opening Studio and clicking 'Create Application' is the standard method. Option B is incorrect because the System Applications module is deprecated for creating applications. Option C is incorrect because it creates individual files, not an application.

Option D is incorrect because the Application Navigator does not have a 'create application' option.

Full explanation →
126
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 →
127
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

Option B is correct because 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 →
128
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 →
129
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

Option B is correct because 'Async' runs the rule in a background thread, improving performance. Option A is incorrect because immediate execution is not async. Option C is incorrect because 'Display' is for form views.

Option D is incorrect because async rules can run on updates.

Full explanation →
130
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

Option A is correct because 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 →
131
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.
AnswerA

UI Policy can conditionally display UI elements and run client scripts.

Why this answer

Option A is correct because UI Policies in Service Portal allow you to define client-side conditions and scripts that can dynamically show or hide UI elements like buttons. By creating a UI Policy on the incident table with a client script, you can conditionally display a custom button that triggers a confirmation dialog before form submission, leveraging the client-side execution context without server round-trips.

Exam trap

The trap here is that candidates often confuse UI Policies with UI Actions, thinking UI Actions are the only way to add buttons, but UI Policies are specifically designed for conditional client-side UI behavior, including showing buttons and triggering client scripts, which matches the requirement for a confirmation dialog before submission.

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 →
132
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

Option A is correct because using setWorkflow(false) and setAutoSysFields(false) reduces system processing. Option B is wrong because using multiple queries increases load. Option C is wrong because batch mode without disabling workflow still runs business rules.

Option D is wrong because setLimit restricts the number of records, which may miss updates.

Full explanation →
133
MCQmedium

A developer is building a Flow in Flow Designer that needs to update an incident record when a certain event occurs. The flow uses a 'Update Record' action. However, the incident record is not being updated even though the flow runs without errors. What could be the issue?

A.The flow trigger is set to 'On Created' but the incident already existed
B.The flow is using a 'Lookup Record' instead of 'Update Record'
C.The flow's application scope does not have write access to the Incident table
D.The 'Update Record' action is referencing the wrong table
AnswerC

Correct; flows in a scoped application require explicit ACL grants to update global tables like Incident.

Why this answer

Option C is correct because the flow's application scope determines the permissions granted to the flow when it executes. Even though the flow runs without errors, if the application scope does not have write access to the Incident table, the 'Update Record' action will silently fail to persist changes. This is a common misconfiguration where the scope's ACLs or table-level permissions are not properly set, causing updates to be discarded without raising an error.

Exam trap

The trap here is that candidates assume a flow running without errors means the update succeeded, but ServiceNow's security model can silently deny write operations when the application scope lacks proper table permissions.

How to eliminate wrong answers

Option A is wrong because the flow trigger being 'On Created' would only prevent the flow from running if the incident already existed before the trigger event; however, the question states the flow runs without errors, meaning the trigger condition is met and the flow executes. Option B is wrong because using a 'Lookup Record' instead of 'Update Record' would not cause a silent failure—it would simply not update the record, and the flow would likely produce a different outcome or error if an update was expected. Option D is wrong because if the 'Update Record' action referenced the wrong table, the flow would either fail with a table-not-found error or update a different table, not silently fail to update the intended incident record.

Full explanation →
134
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

Option B is correct because 'incident' table with 'category' and 'sys_created_on' provides the necessary data. Option A is wrong because 'task' table may include other task types. Option C is wrong because 'cmdb_ci' is not directly related.

Option D is wrong because 'sys_user' is for user data.

Full explanation →
135
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

Correct options A and B. A: onChange fires when a field value changes. B: onSubmit fires when the form is submitted.

C: onLoad is actually a separate type but the name 'onLoad' is correct; the option says 'onLoad' which is valid but we have to choose two. Actually careful: options are A: onChange, B: onSubmit, C: onLoad, D: onDelete, E: onUpdate. The valid types are onChange, onSubmit, onLoad, and onCellEdit.

So A and B are valid; C is also valid but we need exactly two correct. The stem says 'Which TWO' but if three are valid, we need to ensure only two are listed as correct. In this case, we'll make A and B correct, and C incorrect (maybe 'onLoad' is not a type? Actually it is.

But we can say 'onLoad' is not a value for the 'Type' field? Wait, client script types: onChange, onSubmit, onLoad, onCellEdit. So onLoad is valid. To make only two correct, we can change the options: e.g., A: onChange (correct), B: onSubmit (correct), C: onLoad (incorrect?) No, onLoad is correct.

Let's adjust: replace option C with something else like 'onClick' which is not a standard type. So we'll set: A: onChange (correct), B: onSubmit (correct), C: onClick (incorrect), D: onDelete (incorrect), E: onUpdate (incorrect). That works.

Full explanation →
136
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

Option D is correct because a polling interval with a reasonable delay (e.g., 30 seconds) balances freshness and server load. Option A is incorrect because using 'spNavigation' to reload the entire page causes a full page reload, which is inefficient. Option B is incorrect because WebSocket-like channels are not native to Service Portal and require custom setup; plus, real-time is not needed.

Option C is incorrect because calling the GlideAjax each time the user interacts with the widget misses updates when the user is not interacting.

Full explanation →
137
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

Option B is correct because if no records satisfy the condition (active=true but all are inactive), the list will be empty. Option A is wrong because the field is not read-only if the user can click it. Option C is wrong because ACLs are unrelated to reference qualifier results.

Option D is wrong because a dictionary override is not needed for a standard reference field.

Full explanation →
138
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

Option A is correct because the GlideRecord API is not available on the client side; using it directly in a client script causes this error. Option B is wrong because server-side scripts can use GlideRecord without error. Option C is wrong because GlideRecord is not deprecated.

Option D is wrong because the error is clearly in a client script.

Full explanation →
139
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

Option A is correct because `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 →
140
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 →
141
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

Option A is correct because 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 →
142
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

Option B is correct. 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 might cause delays if asynchronous is not properly configured, and still runs the same operation. Option D removes functionality entirely, which is not desired.

Full explanation →
143
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

Option D is correct because 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 →
144
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

Option D is correct because a business rule on the CI table with 'before delete' can query related incidents and update the CI field to empty. Option A (cascade) would delete incidents, not clear. Option B (database trigger) is not supported in ServiceNow.

Option C (workflow) is overly complex for this requirement.

Full explanation →
145
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 →
146
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 →
147
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.
AnswerA

Correct. This causes changes to not be tracked.

Why this answer

Option A is correct because if the application's 'Update Set' field is set to 'None' or 'Not in an update set', changes won't be captured. Option B is wrong because the application is scoped. Option C is wrong because there is no 'Update Set' field on the application record directly; it's a property.

Option D is wrong because phases are irrelevant.

Full explanation →
148
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

Option C is correct because 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 →
149
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

Option D is correct because moving the query to a Business Rule and using a client-callable API (like GlideAjax) offloads the processing to the server and avoids client-side timeouts. Option A is wrong because increasing timeout is not a sustainable fix. Option B is wrong because GlideAggregate is for aggregation, not for retrieving records.

Option C is wrong because adding an index would not help if the query is unfiltered; it would still scan.

Full explanation →
150
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.

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 →