Courseiva

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

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

Take a mock examExam hub
Page 4

Page 5 of 7

Page 6
301
MCQeasy

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

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

The Assignment group field type (sys_user_group) is purpose-built for assignment and integrates with assignment rules, SLA, and notifications.

Why this answer

Option B is correct because the Assignment group field type is specifically designed to link to the System Users table and automatically triggers assignment rules and notifications. Option A is wrong because it would require manual reference setup. Option C is wrong because it only counts users.

Option D is wrong because it is used for grouping users reporting to a manager.

Full explanation →
302
MCQmedium

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

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

sysparm_query allows filtering using encoded queries.

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
303
MCQhard

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

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

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

Why this answer

Option A is correct because the manager field is a reference, and with "Display value" unchecked, the mapping expects a sys_id. Since the LDAP provides a DN, the mapping fails silently, leaving the field empty.

Full explanation →
304
MCQeasy

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

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

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

Why this answer

Option A is correct because the 'Approval' activity in a workflow is the standard way to add approval steps in ServiceNow. Option B is wrong because Business Rules are not typically used for approval routing. Option C is wrong because 'Get Approvals' is not a standard action in Flow.

Option D is wrong because Client Scripts handle client-side behavior, not approval logic.

Full explanation →
305
MCQmedium

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

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

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

Why this answer

Option B is correct because creating a table that extends directly from sys_dictionary with an Integer (numeric) field for the incident reference is not appropriate; instead, using a reference field to the Incident table is standard. Actually, the best approach is to create a new table that extends from the base sys_metadata or use a custom table with a reference field to Incident. The correct answer is to create a table with a reference field to Incident, as it allows linking without inheriting Incident's behavior.

Option A is wrong because extending Incident would inherit unwanted features. Option C is wrong because a database view is read-only and not for storing data. Option D is wrong because the 'Attachment' table is a system table that cannot be extended.

Full explanation →
306
MCQhard

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

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

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

Why this answer

Option A is correct because the Debugger in Studio allows stepping through scripts and viewing execution order. Option B is wrong; Scripts Background is for ad-hoc scripts. Option C is wrong; Flow Designer is for flows.

Option D is wrong; Update Set tracks changes, not execution.

Full explanation →
307
MCQhard

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

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

Correct; after rules cannot update the current record.

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
308
Multi-Selectmedium

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

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

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

Why this answer

For duplicate detection to work, the transform map must have 'Enable Duplicate Detection' checked (A) and the target table must have a unique index on the coalesce field (D). A unique index on the import set table is required for detecting duplicates within the same import set, but the question asks about ignoring duplicates already in the target. Options B and C are incorrect because the source table and import set table indices are not required for target duplicate detection.

Option E is unrelated to duplicate detection.

Full explanation →
309
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
310
MCQeasy

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

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

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
311
MCQmedium

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

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

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

Why this answer

Option C is correct because UI policies are declarative and intended for visibility, read-only, and mandatory conditions, making them easier to maintain and debug. Option A is wrong because client scripts should be used only for complex logic that cannot be achieved with UI policies, not as a default approach. Option B is wrong because workflows are for backend processes, not client-side field behavior.

Option D is wrong because ACLs control data access, not form behavior.

Full explanation →
312
MCQeasy

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

A.Set a default value for the department field in the transform map.
B.Use a coalesce field mapping on the department field.
C.Add a reference qualifier to the department field in the target table.
D.Use a transform script to query the department table and set the reference field.
AnswerD

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

Why this answer

Option A is correct because a transform script can look up the sys_id based on the department name. Option B (coalesce) is for deduplication, not lookup. Option C (default value) would not map to the correct record.

Option D (reference qualifier) restricts the picker but does not handle import mapping.

Full explanation →
313
Matchingmedium

Match each ServiceNow REST API method to its CRUD equivalent.

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

Concepts
Matches

Read

Create

Update (full replacement)

Update (partial)

Delete

Why these pairings

Standard REST methods map to CRUD operations.

Full explanation →
314
Multi-Selectmedium

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

Select 2 answers
A.Script includes cannot call other script includes.
B.Script includes should not have side effects on current record.
C.Script includes must be global to be accessible from all scopes.
D.Script includes can be scoped and still accessible from business rules in the same scope.
E.Script includes are automatically evaluated at server start.
AnswersB, D

Correct; to avoid unintended modifications, script includes should not modify current unless intended.

Why this answer

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

A is incorrect because scoped script includes are accessible within their scope. C is incorrect because script includes can call other script includes. E is incorrect because they are not auto-evaluated.

Full explanation →
315
MCQhard

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

A.The condition 'current.state == 1' is incorrect syntax.
B.Another business rule with higher order is preventing execution.
C.The user does not have read access to the records, so the query does not execute the rule.
D.The business rule is scoped and cannot access the table.
AnswerC

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
316
MCQeasy

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

A.The scheduled import job was interrupted by another job
B.The transform map has a filter that excludes certain records
C.The field mapping is incorrect and some fields are not being populated
D.The JDBC driver has a default row limit that caps the number of records imported
AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
317
MCQhard

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

A.The condition will always evaluate to true regardless of the caller's name.
B.The short_description field will become mandatory for all incidents.
C.The data policy will cause a client-side error.
D.The condition is invalid because dot-walking is not supported in data policy conditions.
AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
318
MCQmedium

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

A.Service Portal and Access Controls (ACLs)
B.Service Portal and Catalog Client Scripts
C.Service Portal and Notifications
D.Service Portal and UI Policies
AnswerC

Service Portal provides the interface; Notifications send status updates.

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
319
MCQhard

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

A.Use a business rule on state update to calculate and store the duration in a custom field.
B.Use a report to calculate the duration on demand.
C.Use a scheduled job to recalculate and update a field daily.
D.Use a calculated field with a formula that references the 'hold_duration' field.
AnswerA

This approach is efficient and updates in real time.

Why this answer

Option C is correct because a business rule on state update can calculate the duration when the state changes to 'On Hold' and store it in a field. Option A (calculated field) cannot reference subrecords or perform complex lookups. Option B (scheduled job) is inefficient and does not update in real time.

Option D (report) only calculates on demand and does not store the value.

Full explanation →
320
MCQeasy

A developer is asked to add a new field to a scoped application's table. The developer opens Studio, navigates to the table, and tries to add a new field but the 'Add Field' button is greyed out. The table is part of the scoped application. The developer has the admin role. Other tables in the same application allow field addition. What is the most likely cause?

A.The application is not set to 'In Process'.
B.The developer does not have the admin role.
C.The table is from a different scope.
D.The table is locked by another developer.
AnswerC

Correct. Tables from other scopes cannot be modified in the current application context.

Why this answer

Option C is correct because if the table is from a different scope (e.g., global scope), you cannot modify it directly from the scoped application. Option A is wrong because locking is not a common feature. Option B is wrong because the developer has admin.

Option D is wrong because application phase does not affect field addition.

Full explanation →
321
MCQmedium

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

A.The form is not refreshing after submission.
B.The business rule is set to run asynchronously.
C.A client script (onLoad) is setting the field back to its original value.
D.A UI Policy is hiding the field.
AnswerC

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

Why this answer

Option B is correct because a client script that runs on load can overwrite the value set by the business rule. Option A is wrong because asynchronous business rules still run in the same transaction and the value would be saved. Option C is wrong because UI Policies control visibility, not values.

Option D is wrong because the form reloads after submission, so it should reflect the updated value.

Full explanation →
322
Multi-Selectmedium

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

Select 2 answers
A.Set 'Application' to the desired scope and check 'Display in application navigator'
B.Create a module pointing to the new table
C.Set 'Label' to 'Incident Custom'
D.Set 'Extends' to 'Incident'
E.Set 'Extends' to 'Task'
AnswersA, D

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

Why this answer

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

Exam trap

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

Full explanation →
323
MCQhard

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

A.Check the browser's HTML source for the macro's placeholder.
B.Ensure the UI Macro is in the global scope.
C.Verify that all referenced UI Scripts are loaded.
D.Examine the UI Macro record for syntax errors in the HTML or Jelly script.
AnswerD

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

Why this answer

Option B is correct because the most common issue is a syntax error in the macro definition that prevents rendering. Option A is wrong because checking the HTML source is possible but not the first step. Option C is wrong because UI Scripts are separate from macros.

Option D is wrong because scope issues are less likely than syntax errors.

Full explanation →
324
MCQmedium

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

A.The 'Account lockout after invalid attempts' property is set too low
B.The 'Single Sign-On (SSO)' module is disabled in the ServiceNow application menu
C.The IdP's signing certificate has been rotated, but the new certificate is not uploaded to ServiceNow
D.The 'AuthnRequest Signed' checkbox is not enabled in the SAML2 configuration
AnswerC

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
325
MCQeasy

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

A.Create an After Insert Business Rule that updates the project ID after the record is saved.
B.Create a Before Insert Business Rule that uses a script to query the current count of records and generate the next ID.
C.Create a calculated field that uses a scripted formula to generate the ID.
D.Create a Default Value for the project ID field using a script that calls a helper function.
AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
326
Multi-Selectmedium

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

Select 3 answers
A.Utilize the Studio Debugger to test business rules and script includes.
B.Always create application files using the UI instead of importing XML files.
C.Use the Application Explorer to view all application artifacts.
D.Set the application version number manually in the application properties.
E.Avoid using update sets for scoped applications because they are automatically managed.
AnswersA, C, E

Correct: Debugger allows stepping through server-side scripts.

Why this answer

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

Exam trap

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

Full explanation →
327
MCQeasy

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

A.Use a server-side script with a polling model to return data on a timer.
B.Use a third-party library for WebSocket connections.
C.Use a widget option to set the refresh rate and a server-side script to fetch data.
D.Use a client-side JavaScript interval to reload the page.
AnswerC

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

Why this answer

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

Full explanation →
328
MCQeasy

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

A.current.getDisplayValue('priority') != previous.getDisplayValue('priority')
B.current.priority.changes()
C.current.changes()
D.previous.priority != current.priority
AnswerB

This method returns true exactly when the priority field changes.

Why this answer

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

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

Full explanation →
329
MCQmedium

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

A.To ignore records with empty department.
B.To map the department field only if source department is not empty.
C.To set a default value for the department field.
D.To map all fields from source to target.
AnswerB

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

Why this answer

The correct answer is D. The script maps the 'department' field only if the source field 'u_department' is not empty. Option A is incorrect because it does not set a default value.

Option B is incorrect because it only maps one field conditionally. Option C is incorrect because it does not ignore records; it just skips the mapping.

Full explanation →
330
MCQhard

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

A.The business rule is set to run 'On Update' and also 'On Insert'
B.The business rule order is too high
C.The business rule script updates the same record, causing a loop
D.The business rule exists in two different scoped applications
AnswerC

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
331
MCQmedium

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

A.Use $scope.$broadcast to trigger a modal event
B.Use spModal.open with the record producer sys_id
C.Use $uibModal.open to create a modal with a custom template
D.Use window.open to open the record producer URL
AnswerC

$uibModal is the Angular UI Bootstrap service for modals.

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
332
Multi-Selecthard

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

Select 2 answers
A.Disable business rules and ACLs during import.
B.Increase the import set table row limit.
C.Enable 'Create multiple' for transform maps.
D.Use a single transform map for all records.
E.Use scheduled imports instead of manual imports.
AnswersA, E

This reduces overhead and speeds up import significantly.

Why this answer

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

Full explanation →
333
MCQhard

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

A.Change the button to a direct link to a different page.
B.Create a script include with the reassign logic, and call it from the widget server-side script using a client callable action.
C.Move the entire reassign logic to a client-side script using GlideRecord via Ajax.
D.Use a custom UI macro instead of a widget.
AnswerB

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

Why this answer

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

Full explanation →
334
MCQhard

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

A.The getTotal method is not properly defined.
B.The 'amount' field is not numeric in the invoice table.
C.The GlideAggregate query syntax is incorrect.
D.The script include is not accessible from the Business Rule's scope.
AnswerB

Non-numeric field causes SUM to return null.

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
335
MCQeasy

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

A.Use GET methods for data modification.
B.Use versioning in the API path.
C.Pass sensitive data in URL parameters.
D.Return all data without pagination.
AnswerB

Correct: Versioning allows backward compatibility.

Why this answer

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

Full explanation →
336
MCQeasy

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

A.Business Rule
B.Events
C.Script Include
D.Scheduled Job
AnswerD

Scheduled Jobs run at defined intervals.

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
337
Multi-Selectmedium

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

Select 2 answers
A.The table must have a unique name starting with 'u_'
B.The table should be created in the global scope to ensure universal access
C.The table must have a reference field back to the parent table
D.The number of records in the parent table may impact query performance when retrieving child records
E.Adding too many fields to the extended table can degrade performance and increase complexity
AnswersD, E

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

Why this answer

Options B and D are correct because extending tables can increase complexity and affect performance, and adding unnecessary fields leads to maintenance issues. Options A, C, and E are incorrect or not directly related to table extension considerations.

Full explanation →
338
MCQhard

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

A.The script include is not marked as 'Client-callable'.
B.The client script is running in a UI policy instead of a client script.
C.The script include is a global scope but the client script is in a scoped application.
D.The client script is not using the correct GlideAjax syntax.
AnswerC

In scoped apps, GlideAjax may not be available for global script includes unless explicitly allowed.

Why this answer

Option C is correct because when a script include is marked as client-callable, it must be in the global scope to be accessible from a client script via GlideAjax. If the script include is in a scoped application and the client script is in a different scope (or even the same scope), the GlideAjax call will fail because scoped script includes are not automatically available to client-side code unless explicitly exposed via the 'Accessible from' property. The error 'GlideAjax is not defined' indicates the client-side API cannot find the script include, which is a scope isolation issue.

Exam trap

ServiceNow often tests the misconception that marking a script include as client-callable is sufficient for it to be used from any client script, ignoring the scope isolation requirement that client-callable script includes must be in the global scope.

How to eliminate wrong answers

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

Full explanation →
339
MCQeasy

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

A.Use GlideRecord with setWorkflow(false) and setEngine(false) to update records in a loop.
B.Use GlideAggregate to perform the update.
C.Use an export set to update records in bulk.
D.Use the updateMultiple method on a GlideRecord object.
AnswerA

Correct: This method reduces overhead by disabling business rules and workflow.

Why this answer

Option A is correct because using GlideRecord in combination with setWorkflow(false) and setEngine(false) prevents unnecessary business rules and workflow execution, reducing overhead. Option B is wrong because GlideAggregate is for aggregation, not updates. Option C is wrong because updateMultiple can be more efficient but still triggers business rules if not disabled.

Option D is wrong because export set is not meant for updates.

Full explanation →
340
MCQmedium

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

A.The view must include the 'active' field from both tables
B.UNION should be UNION ALL to retain duplicate rows
C.A database view cannot combine records from incident and problem tables
D.The SELECT statement should include DISTINCT
AnswerB

UNION deduplicates rows, reducing the count if overlaps exist.

Why this answer

Option A is correct. UNION removes duplicate rows; if there are overlapping records (same sys_id, number, short_description), they are eliminated. Using UNION ALL would keep all rows.

Option B (DISTINCT) is already implied by UNION. Option C is false because views can combine tables. Option D is false because the 'active' field is not required.

Full explanation →
341
MCQhard

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

A.The user does not have permission to run business rules on the 'u_staff' table
B.Business rules on the User table do not fire on child table records
C.The business rule has a condition that only allows running on User table records
D.The business rule ordering is set too low and is being skipped
AnswerB

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

Why this answer

Option C is correct because Business rules on a parent table do not automatically fire on child table records unless specifically set to. Option A is wrong because business rules on User will not fire on activities on child tables unless configured. Option B is wrong because the condition can check both.

Option D is wrong because ordering does not prevent firing.

Full explanation →
342
MCQhard

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

A.The 'serial_number' field in the 'alm_asset' table does not exist or is misspelled
B.The GlideRecord.get() method is incorrectly used; it should be gr.get('serial_number') without the value
C.The request body is not being parsed; 'request.body' is null because the content type is not set to JSON or the API is not expecting a body
D.The external system is sending the serial number as part of the URL instead of the request body
AnswerC

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
343
MCQeasy

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

A.Check the form layout to ensure the field is present on the form.
B.Check the client script that may be hiding the field.
C.Check the ACLs for the 'Cost Center' field.
D.Check the role requirements for the field.
AnswerA

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

Why this answer

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

Full explanation →
344
MCQhard

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

A.There is another ACL with a lower order that grants read access to all users, and the evaluation never reaches the scripted ACL.
B.The ACL is cached and users need to log out and back in for changes to take effect.
C.The condition script returns 'true' for users in the group but does not return 'false' for others, so the ACL defaults to 'no decision' and access is allowed.
D.The ACL is set to 'Inactive' so it does not apply, leaving access open.
AnswerA

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

Why this answer

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

Exam trap

The trap here is that candidates assume a condition script that only returns 'true' for allowed users will automatically deny others, but in ServiceNow, an ACL must explicitly return 'false' to deny access; otherwise, the system treats it as 'no decision' and continues evaluating subsequent ACLs.

How to eliminate wrong answers

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

Full explanation →
345
Multi-Selecteasy

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

Select 2 answers
A.Table label
B.Access control rules
C.Extensible checkbox
D.Application scope
E.Table name
AnswersA, E

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

Why this answer

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

Exam trap

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

Full explanation →
346
MCQmedium

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

A.The field u_extra_field was recently deleted from the table.
B.The table name is misspelled in the script.
C.The script include has a syntax error.
D.The field u_extra_field exists but is not indexed.
AnswerA

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
347
MCQeasy

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

A.UI Script (sys_ui_script)
B.Portal Theme (sp_theme)
C.UI Theme (sys_ui_theme)
D.Branding (sys_brand)
AnswerC

UI Themes define the styling for UI16.

Why this answer

Option A is correct because UI16 themes are managed through the 'sys_ui_theme' table. Option B is wrong because UI Scripts are for JavaScript functions, not themes. Option C is wrong because branding records are for logos and colors but not full themes.

Option D is wrong because portal themes are for Service Portal, not UI16.

Full explanation →
348
Drag & Dropmedium

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

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

Steps
Order

Why this order

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

Full explanation →
349
MCQeasy

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

A.Verify that a script include used in the condition is accessible
B.Ensure the field has a 'Mandatory' attribute on the dictionary
C.Check if the 'Mandatory' ACL on the field prevents modification
D.Review the UI Policy conditions and the order of policies on the form
AnswerD

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

Why this answer

Option B is correct because checking the UI Policy conditions and order is the logical first step. Option A is incorrect because the field must already exist. Option C is incorrect because UI Policies do not use script includes.

Option D is incorrect because ACLs do not affect mandatory behavior.

Full explanation →
350
MCQmedium

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

A.The function runs successfully and gs.getUser() returns the current user from the caller's session.
B.An error occurs because scoped Script Includes cannot be called from other applications.
C.The function runs but gs.getUser() returns the user from the Script Include's application scope, not the caller.
D.The function runs but returns null because gs is not available in scoped applications.
AnswerA

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
351
MCQmedium

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

A.The script sets the field using 'current.u_assignee = null;' instead of 'current.setValue("u_assignee", "");'.
B.The Business Rule is set to run after the record is saved, so changes are overwritten.
C.The condition 'current.u_status.changesTo("Retired")' is incorrect.
D.The Business Rule runs after update instead of before update.
AnswerA

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
352
Multi-Selecthard

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

Select 2 answers
A.Set the 'table' access policy to 'Internal'
B.Extend the 'incident' table instead of 'task'
C.Enable the 'Allow web service access' property on the table
D.Extend the 'task' table
E.Create ACLs on the table to restrict read access to HR users
AnswersD, E

Task provides assignment and state fields.

Why this answer

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

Exam trap

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

Full explanation →
353
Multi-Selectmedium

Which TWO statements about ServiceNow UI Policies are true?

Select 2 answers
A.UI Policies can enforce data integrity at the database level
B.UI Policies can set fields as mandatory
C.UI Policies cannot be used on catalog items
D.UI Policies can have multiple script actions
E.UI Policies run on the server side only
AnswersB, D

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

Why this answer

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

Exam trap

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

Full explanation →
354
MCQmedium

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

A.PUT
B.PATCH
C.GET
D.POST
AnswerD

POST is the standard method for creating new resources.

Why this answer

Option B is correct: POST is used to create new resources. Option A is wrong because GET retrieves data. Option C is wrong because PUT updates/replaces.

Option D is wrong because PATCH updates partially.

Full explanation →
355
MCQmedium

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

A.Create a Business Rule on 'Before Insert' that sets the priority
B.Create a Client Script that runs onLoad and sets priority
C.Use a UI Policy to set priority based on category
D.Define a default value script in the dictionary for the priority field
AnswerD

Executes at database level with no extra rule overhead.

Why this answer

Option B is correct because a default value script in the dictionary runs server-side during record insertion and is efficient. Option A (Business Rule) also works but adds unnecessary overhead. Option C (Client Script) is client-side and can be bypassed.

Option D (UI Policy) does not set field values.

Full explanation →
356
Multi-Selecteasy

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

Select 2 answers
A.Duplicate an existing UI Action from the list view.
B.Create a new UI Action record from the UI Actions module.
C.Write a Script Include and configure it as a UI Action.
D.Create a UI Action from the Form Design interface.
E.Create a UI Action from the Business Rules module.
AnswersA, B

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

Why this answer

Options A and D are correct. UI Actions can be created directly via the UI Actions module (sys_ui_action) or by duplicating an existing one. Option B is wrong because Form Design is for layout, not UI Actions.

Option C is wrong because Script Includes are separate server-side scripts. Option E is wrong because Business Rules are a different record type.

Full explanation →
357
MCQhard

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

A.Increase the server timeout value to allow more time for the query to complete.
B.Implement pagination in the server script and modify the widget to load data in chunks.
C.Add a client-side filter to the widget to display only a subset of records.
D.Use a UI Policy to hide the widget for users with many requests.
AnswerB

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
358
Multi-Selecteasy

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

Select 2 answers
A.JDBC
B.REST
C.LDAP
D.SNMP
E.Syslog
AnswersA, B

JDBC allows importing from external databases.

Why this answer

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

Full explanation →
359
Multi-Selecteasy

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

Select 2 answers
A.Schedule the import to run during off-peak hours
B.Use REST API instead of import sets for better performance
C.Use update sets to manage import set configurations
D.Use coalesque in the transform map to avoid duplicates
E.Always use a staging table for all data sources
AnswersA, D

Scheduling minimizes impact on system performance.

Why this answer

Options A and C are correct. A: Coalescing on a unique field prevents duplicate records. C: Scheduling imports ensures regular updates.

B is not a best practice because staging tables are used but not always required. D is incorrect because REST API is an alternative, not a best practice for import sets. E is not relevant to import sets.

Full explanation →
360
MCQeasy

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

A.The table name 'u_software_license' is not compatible with the Software module.
B.The 'Display in application navigator' checkbox is not checked on the table configuration.
C.A module has not been created to reference the new table.
D.The table extends 'Task' instead of 'Software', so it cannot appear in the Software module.
AnswerB

This checkbox must be checked for the table to appear in the navigator.

Why this answer

The table does not appear in the 'Software' module because a module entry in the application navigator must be explicitly created to point to the table. Simply creating the table and setting its properties does not automatically add it to a module; you must create a module record that references the table and is placed under the 'Software' module. Option B is incorrect because the 'Display in application navigator' checkbox controls whether the table itself appears as a standalone entry in the navigator, not whether it appears within an existing module.

Exam trap

The trap here is that candidates confuse the 'Display in application navigator' checkbox with the requirement to create a module, leading them to think the checkbox controls module visibility, when in fact a module record is the only way to place a table under a specific module in the navigator.

How to eliminate wrong answers

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

Full explanation →
361
MCQhard

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

A.Use a RESTMessageV2 with Basic Authentication.
B.Add the username and password to the SOAP message's HTTP headers.
C.Configure the WS-Security tab under the SOAP Message record with UsernameToken and timestamp.
D.Set the SOAP action header to include the token.
AnswerC

The SOAP Message record has dedicated WS-Security settings.

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
362
Multi-Selecteasy

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

Select 2 answers
A.Widgets automatically handle user authentication.
B.Widgets can be easily reused across multiple portals.
C.Widgets provide built-in accessibility features.
D.Widgets are faster because they use synchronous server calls.
E.Widgets support AngularJS data binding.
AnswersB, E

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

Why this answer

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

Exam trap

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

Full explanation →
363
MCQhard

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

A.If the user is from the company specified, regardless of the assigned_to field.
B.If the user is from the company specified in the property and the incident is assigned to the user.
C.If the user is from the company specified and the incident is assigned to the user's manager.
D.If the user's manager is from the company specified and the incident is assigned to the user.
AnswerC

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
364
MCQmedium

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

A.Create a SOAPMessage object and use the send() method.
B.Use the XMLDocument object to parse the response only.
C.Use a GlideRecord insert to write the SOAP envelope to a table.
D.Use the RESTMessageV2 object to send the request as a POST.
AnswerA

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
365
Drag & Dropmedium

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

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

Steps
Order

Why this order

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

Full explanation →
366
MCQmedium

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

A.List report
B.Pie chart
C.Line chart
D.Bar chart
AnswerD

Bar chart effectively shows counts per day.

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
367
MCQhard

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

A.Reorder the business rules so that 'Asset Log' runs first and 'Asset Assignment' runs second, and add a condition to 'Asset Log' to only run if the assignment succeeded.
B.Remove the condition from 'Asset Assignment' and move the field existence check into the script, setting the field value only if it exists.
C.Deactivate the 'Asset Assignment' business rule until the field is added to the table in production, then reactivate it after the next maintenance window.
D.Change the condition script to check if the field exists before using it, and if not, exit the script gracefully.
AnswerD

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

Why this answer

Option A is correct because it is the quickest fix with minimal disruption: adding a condition check prevents the business rule from failing when the field is missing, and the rule will run correctly once the field is added. Option B is incorrect because reordering does not fix the root cause; the first rule can run, but the second would still fail if the field is missing. Option C is incorrect because removing the condition entirely would cause the script to run on every insert, which might have unintended side effects, and the field existence check in the script would still be needed.

Option D is incorrect because deactivating the rule prevents the intended functionality entirely until the field is added, which is more disruptive.

Full explanation →
368
MCQeasy

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

A.Use a List Collector field to allow multiple categories
B.Create a Choice field with the four categories, and then configure a UI policy to show different icons based on the selected value
C.Create a custom table 'u_category' and a reference field on 'u_company_asset' pointing to it
D.Use a single-line text field and manually enter the categories
AnswerB

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

Why this answer

Option A is correct because a Choice field provides a simple drop-down list and supports image mappings. Option B is wrong because a List Collector is for multiple selections. Option C is wrong because a custom table is overkill.

Option D is wrong because a string field does not support predefined values.

Full explanation →
369
MCQmedium

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

A.The condition script must return true explicitly for the ACL to deny access.
B.The ACL is set to condition type 'script' but the script is not structured correctly.
C.The isMemberOf method requires a group sys_id, not a user ID.
D.There is another ACL on the incident table that grants read access to users with the 'itil' role without the group membership check.
AnswerD

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
370
MCQeasy

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

A.REST API Explorer
B.Business Rule with outbound REST call
C.Access Control List (ACL)
D.Scheduled Job
AnswerB

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
371
MCQeasy

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

A.Create a UI Policy that hides the field when the condition is met.
B.Modify the form layout to remove the field.
C.Use a catalog client script to hide the field.
D.Write a client script to set the field's display property to false on load.
AnswerA

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

Why this answer

Option B is correct because UI Policies are designed to control field visibility, read-only, and mandatory states on forms based on conditions. Option A is wrong because the form layout only defines the initial arrangement but does not dynamically hide fields. Option C is wrong because client scripts can set values but are not ideal for visibility control; UI Policy is declarative and more efficient.

Option D is wrong because a catalog client script could be used but is less standard than UI Policy for visibility.

Full explanation →
372
MCQmedium

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

A.In Studio, right-click the table and select 'Add Field'.
B.Create a new field in the application's schema.
C.Use the Application Builder to add a table extension.
D.Navigate to System Definition > Tables and add the field.
AnswerB

Standard method in Studio.

Why this answer

Option A is correct because fields are added via the application's schema in Studio. Option B is incorrect as Application Builder is not the primary method. Option C is incorrect because right-click does not offer 'Add Field'.

Option D is incorrect because navigating to System Definition is for global tables.

Full explanation →
373
MCQhard

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

A.The business rule will not fire because condition is invalid.
B.Nothing, because there is no script.
C.The business rule will cause an error because script is required.
D.The business rule will still fire and execute default actions.
AnswerB

Correct; the rule fires but does nothing.

Why this answer

Option A is correct because an empty script does nothing; no action is taken. Option B is incorrect because there are no default actions. Option C is incorrect because a script is not required.

Option D is incorrect because the condition is valid.

Full explanation →
374
MCQmedium

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

A.The password for the integration user does not meet complexity requirements.
B.The integration user does not have the 'rest_api' role.
C.The OAuth token used for authentication has expired or is invalid.
D.The integration is hitting a table ACL that denies read access.
AnswerC

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

Why this answer

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

Exam trap

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

How to eliminate wrong answers

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

Full explanation →
375
MCQeasy

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

A.Using g_l.get('field_name')
B.Using g_form.getValue(document.getElementById('field_name'))
C.Using g_form.getValue('field_name')
D.Using GlideRecord.get() to query the field value
AnswerC

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

Why this answer

Option D is correct because g_form is the standard client-side API for form manipulation. Option A is incorrect because GlideRecord is server-side only. Option B is incorrect because g_l is for GlideAjax.

Option C is incorrect because g_form.getValue() requires the field name as a string, not the element ID.

Full explanation →
Page 4

Page 5 of 7

Page 6

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 →