Courseiva

ServiceNow Certified Application Developer CAD (SNOW-CAD) — Questions 376–450

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

Take a mock examExam hub
Page 5

Page 6 of 7

Page 7
376
MCQhard

A Service Portal widget uses an AngularJS controller that directly modifies the DOM using jQuery inside the controller. After a platform upgrade, the widget stops working properly. What is the most likely reason?

A.jQuery is no longer allowed
B.Direct DOM manipulation conflicts with AngularJS digest cycles
C.The widget's controller syntax changed
D.AngularJS was completely removed from the platform
AnswerB

Correct: After an upgrade, digest cycles may behave differently, causing DOM changes to be overwritten.

Why this answer

Service Portal's AngularJS-based architecture is moving away from direct DOM manipulation. The correct approach is to use AngularJS data binding. The upgrade may have changed the order of digest cycles, causing inconsistencies.

Full explanation →
377
MCQeasy

A ServiceNow instance needs to synchronize data with an external SQL database nightly. Which integration method is most appropriate?

A.Use a REST API exposed by the external database.
B.Use a MID Server with a JDBC data source.
C.Use a SOAP web service with a MID Server.
D.Use an email-based integration to send CSV files.
AnswerB

JDBC provides direct database connectivity through the MID Server.

Why this answer

A MID Server with a JDBC data source is the most appropriate method for nightly batch synchronization with an external SQL database because JDBC provides a direct, efficient, and secure database-level connection without requiring the external database to expose a web service or API. The MID Server acts as a secure proxy, allowing the ServiceNow instance to execute SQL queries against the external database over a persistent, encrypted connection, which is ideal for scheduled bulk data transfers.

Exam trap

The trap here is that candidates often assume REST APIs are the universal integration method, but for direct SQL database synchronization, JDBC via a MID Server is the native and most efficient approach, while REST would require an additional middleware layer that the external database likely does not provide.

How to eliminate wrong answers

Option A is wrong because using a REST API exposed by the external database would require the database to have a custom REST layer, which is not a standard feature of most SQL databases and adds unnecessary complexity and overhead for a simple nightly batch sync; REST APIs are better suited for real-time, granular operations. Option C is wrong because a SOAP web service with a MID Server is over-engineered for this scenario—SOAP is heavyweight, requires WSDL definitions, and is typically used for complex transactional integrations, not for straightforward nightly SQL data pulls. Option D is wrong because an email-based integration sending CSV files is unreliable for scheduled data synchronization due to lack of guaranteed delivery, file size limits, and no built-in error handling or retry mechanisms, making it unsuitable for production data syncs.

Full explanation →
378
MCQeasy

In a transform map, a field mapping uses the condition 'if target field is empty'. What does this mean?

A.Only maps if both source and target are empty
B.Always maps regardless
C.Only maps if target field is empty
D.Only maps if source field is empty
AnswerC

That is the 'if target field is empty' condition.

Why this answer

The condition 'if target field is empty' means the mapping is applied only when the target field is currently empty. Option A is wrong because it incorrectly says both source and target must be empty. Option B is wrong because it says always maps, but the condition restricts mapping.

Option D is wrong because it checks source field, not target.

Full explanation →
379
MCQeasy

In ServiceNow Studio, which role is required to create a new scoped application?

A.A global scope update set
B.No special role; any user can create applications
C.Application Creator role
D.Admin role
AnswerD

Admin role is required.

Why this answer

Only users with the admin role can create scoped applications in ServiceNow Studio. Option A is incorrect because a global scope update set is not a role; it is a type of update set. Option B is incorrect because not all users have the ability to create applications; it requires the admin role.

Option C is incorrect because the Application Creator role does not exist as a standard role; the admin role is required.

Full explanation →
380
MCQhard

A company has implemented a custom application for tracking employee training. The application uses a custom table 'u_training' with fields: u_employee (reference to sys_user), u_course (string), u_completion_date (date), and u_status (choice: Not Started, In Progress, Completed). The application has a Business Rule that runs after insert and after update. The rule should send an email notification to the employee when the status changes to 'Completed'. However, the email is not being sent. The developer has verified that the notification record exists and is active. The Business Rule script uses the 'gs.eventQueue' method to trigger a custom event. The event is registered and the notification is configured to be triggered by that event. What is the most likely cause of the issue?

A.The event name is misspelled in the gs.eventQueue call.
B.The Business Rule does not have a condition to check if the status changed to 'Completed'.
C.The notification is set to 'Inactive'.
D.The employee's email address is not set in sys_user.
AnswerB

Without a condition, the event is fired on every insert and update, but the notification may have a condition that checks status. However, the likely issue is that the rule fires on all updates, but the notification condition might not be met. More precisely, the rule should fire only when status changes to Completed.

Why this answer

The Business Rule lacks a condition to verify that the status field actually changed to 'Completed'. Without a condition like `current.u_status.changesTo('Completed')`, the rule fires on every insert and update, calling `gs.eventQueue` even when the status hasn't changed. This means the event is triggered unnecessarily, but more critically, the notification may not fire because the event is not scoped to the specific state transition.

The developer verified the notification record is active, so the missing condition is the most likely root cause.

Exam trap

The trap here is that candidates assume the Business Rule will always fire the event, overlooking the need for a condition to check the specific field change, which is a common oversight in ServiceNow development.

How to eliminate wrong answers

Option A is wrong because if the event name were misspelled in `gs.eventQueue`, the event would not fire at all, and the developer would likely see an error or no event in the system log; however, the question states the event is registered and the notification is configured, so a misspelling would be a basic mistake that would be caught early. Option C is wrong because the developer explicitly verified that the notification record exists and is active, so it cannot be set to 'Inactive'. Option D is wrong because while a missing email address would prevent delivery, the question focuses on the Business Rule logic; the email not being sent is due to the event not being triggered correctly, not a recipient configuration issue, and the developer would have checked the user record if that were the case.

Full explanation →
381
MCQmedium

A ServiceNow administrator notices that a business rule designed to update the 'short_description' field on the 'incident' table is not executing when a user changes the field via a custom UI page that uses GlideRecord. The script in the business rule uses current.setValue() and current.update(). What is the most likely cause?

A.The 'short_description' field is read-only on the form.
B.The business rule is updating itself recursively and has been disabled.
C.The business rule is set to run on the server, but the custom UI page uses client-side GlideRecord which does not trigger server-side business rules.
D.The 'short_description' field is not in the business rule's 'Fields to update' list.
AnswerC

Client-side GlideRecord operations do not invoke server-side business rules; they go directly to the database without triggering 'after' update logic.

Why this answer

Client-side GlideRecord (g_form.getReference or direct GlideRecord in a UI page) runs entirely in the browser and does not trigger server-side business rules. Business rules execute only when a record is saved via server-side operations (e.g., form submit, web service, or server-side script). Since the custom UI page uses client-side GlideRecord, the update bypasses the business rule engine entirely.

Exam trap

The trap here is that candidates often assume any GlideRecord call triggers business rules, but client-side GlideRecord bypasses server-side execution, and the exam tests this specific distinction between client-side and server-side script execution contexts.

How to eliminate wrong answers

Option A is wrong because a read-only field on the form only prevents user input on that form; it does not prevent a business rule from updating the field via current.setValue() and current.update(). Option B is wrong because if the business rule were updating itself recursively, it would cause a loop and potentially be disabled by the system, but the question states the rule is not executing at all, not that it was disabled due to recursion. Option D is wrong because the 'Fields to update' list is not a property of business rules; business rules do not have a 'Fields to update' list—that concept applies to dictionary overrides or field-level security, not business rule execution.

Full explanation →
382
MCQhard

A company has a requirement that the 'state' field of an incident cannot be changed from 'In Progress' to 'Resolved' if the 'category' field is empty. This validation must be enforced server-side to prevent data integrity issues. Which implementation should be used?

A.Make the 'category' field mandatory using a Data Policy.
B.Configure an ACL on the 'state' field to deny write access when category is empty.
C.Create a Client Script on 'state' change that checks if category is empty and shows an error message.
D.Create a 'before' Business Rule that checks if the state is changing to 'Resolved' and if category is empty, aborts the update with an error message.
AnswerD

Before Business Rules can prevent updates by returning false and setting error messages.

Why this answer

A 'before' Business Rule runs server-side and can check if the state is changing to 'Resolved' and if the category field is empty. Using gs.addErrorMessage() and returning false aborts the update, enforcing the validation server-side. Option A (Data Policy) would make category mandatory globally, not only during the specified state transition.

Option B (ACL) controls field-level access but cannot validate value transitions. Option C (Client Script) runs client-side and can be bypassed.

Full explanation →
383
MCQmedium

An administrator notices that a custom table called 'u_equipment' does not appear in the 'New Record' context menu of the application navigator. What is the most likely cause?

A.The table was not added to an application menu in the navigation module
B.The table is extended from a table that is not in the navigator
C.The table has a business rule that prevents new record creation
D.The 'Create new' option is inherited from the parent table
AnswerA

Correct. Application menus must be manually configured to include custom tables for them to appear in the 'New Record' menu.

Why this answer

Custom tables must be added to an application menu in the navigation module to appear in the 'New Record' context menu. Option B is incorrect because tables extended from a parent table can appear independently if configured. Option C is incorrect because business rules do not affect navigator menu visibility; they only influence record creation actions.

Option D is incorrect because the 'Create new' option is not inherited from the parent table; it requires explicit configuration.

Full explanation →
384
MCQeasy

What is the effect of this business rule?

A.It will cause an error because assignment_group is a reference field.
B.It only runs when both caller and short description change.
C.It sets assignment_group to 'IT Support' every time the caller or short description changes.
D.It only sets assignment_group when the incident is first created.
AnswerC

Correct; the condition OR means either change triggers the script.

Why this answer

The business rule is configured to trigger 'on change' for both the 'caller' and 'short description' fields. When either field changes, the rule sets the 'assignment_group' field to 'IT Support'. This is a typical use of a business rule to automatically assign incidents based on field updates.

Exam trap

The trap here is that candidates often confuse the condition logic (thinking 'changes to caller OR short description' means both must change) or assume reference fields cannot be set by business rules, leading them to pick option A or B.

How to eliminate wrong answers

Option A is wrong because assignment_group is a reference field, but business rules can set reference fields by specifying a sys_id or a name that resolves to a valid record; no error occurs as long as the value exists. Option B is wrong because the condition uses OR logic (either field changes), not AND; the rule runs when caller OR short description changes, not only when both change. Option D is wrong because the rule is not restricted to the 'on insert' event; it runs on updates as well, so it sets assignment_group whenever the specified fields change, not just on creation.

Full explanation →
385
MCQmedium

A company has a Service Portal that includes a custom widget for submitting hardware requests. The widget has a client controller that calls a server script to create a new record in the 'hardware_request' table. Recently, users have reported that when they click the 'Submit' button, the widget sometimes does not show a success message, and the record is not created. The developer reviews the server script, which uses gs.log to log errors, and sees no errors in the logs. The client controller uses $scope.server.get() to call the server. The widget template uses ng-show='data.success' to display a success message. Based on this scenario, what is the most likely cause of the intermittent issue?

A.The server script fails due to a mandatory field not being provided, but the error is not logged.
B.The server script uses data.success = true; but the client controller does not read it.
C.The widget has a Client Script that conflicts with the server script.
D.The client controller does not handle the asynchronous response properly; the success message depends on the promise resolving before the user might navigate away or click again.
AnswerD

Asynchronous calls require proper handling of promises to update scope.

Why this answer

The client controller uses $scope.server.get() to make an asynchronous call to the server script. If the user clicks 'Submit' and then navigates away or clicks again before the promise resolves, the success message (ng-show='data.success') may never display because the $scope.data object is not updated in time. The server script logs no errors because it executes correctly, but the client-side asynchronous handling fails to capture the response, leading to the intermittent issue.

Exam trap

ServiceNow often tests the misconception that server-side errors are the only cause of missing success messages, but the trap here is that asynchronous client-side handling (promise resolution and digest cycles) can silently fail to update the UI even when the server executes correctly.

How to eliminate wrong answers

Option A is wrong because the server script uses gs.log to log errors, and the developer sees no errors in the logs, indicating that mandatory fields are likely provided and the script executes without failure. Option B is wrong because if the server script sets data.success = true, the client controller would read it via the $scope.server.get() response, which updates $scope.data; the issue is not that the client controller fails to read it, but that the response may not be processed due to asynchronous timing. Option C is wrong because there is no mention of a Client Script in the widget, and a conflicting Client Script would likely produce consistent errors or logs, not intermittent failures with no logged errors.

Full explanation →
386
MCQeasy

In ServiceNow Studio, when developing a flow that requires a decision based on a record's category, which component should be used?

A.Action
B.Flow Logic
C.Trigger
D.Condition
AnswerD

Conditions evaluate expressions and allow branching based on the category.

Why this answer

A Condition component is used to evaluate criteria and branch the flow. Action performs operations, Trigger initiates the flow, and Flow Logic is not a component.

Full explanation →
387
MCQeasy

A developer needs to create a new table to store custom survey responses. The table should have a field to store the survey name and a field to store the response text. The developer wants to ensure that the table is available in the 'Surveys' application module. Which property must be set on the table?

A.Application scope
B.Table name
C.Table label
D.Application module
AnswerD

This defines the module where the table appears.

Why this answer

The Application module property determines which application module a table belongs to, making it visible and accessible within that module's scope. Setting this to 'Surveys' ensures the table appears in the Surveys application module, as required by the developer.

Exam trap

ServiceNow often tests the distinction between Application scope (which controls access and isolation) and Application module (which controls UI placement), leading candidates to confuse the two.

How to eliminate wrong answers

Option A is wrong because Application scope defines the application's namespace and access permissions, not the module where the table is displayed. Option B is wrong because the Table name is a unique identifier for the table but does not control its visibility in a specific application module. Option C is wrong because the Table label is a human-readable name shown in the UI, but it does not assign the table to a particular application module.

Full explanation →
388
MCQmedium

A developer created the business rule shown in the exhibit to auto-generate asset tags. However, when a new asset is created, sometimes the generated tag is a duplicate of an existing tag. What is the most likely cause?

A.The condition '!current.u_asset_tag' fails when the field is empty
B.The script does not account for records with null asset tags
C.The script does not handle the scenario when no asset tag exists
D.The query uses 'CONTAINS' which may match unintended tags, and ordering by sys_created_on may not guarantee the highest number
AnswerD

CONTAINS can match multiple patterns, and ordering by creation time may not reflect the highest number.

Why this answer

The script uses a glide query with 'CONTAINS' to find the highest existing asset tag number, which can match unintended tags (e.g., 'TAG-10' matching 'TAG-1001'), and ordering by 'sys_created_on' does not guarantee the highest numeric suffix. This leads to duplicate tags when the generated number is already in use but not detected as the maximum.

Exam trap

ServiceNow often tests the subtle flaw of using 'CONTAINS' for numeric suffix extraction, where candidates overlook that substring matching can return unintended records, and assume ordering by creation time is sufficient for determining the highest number.

How to eliminate wrong answers

Option A is wrong because the condition '!current.u_asset_tag' correctly evaluates to true when the field is empty (null or empty string), so it does not fail. Option B is wrong because the script explicitly checks for null/empty asset tags via the condition, so it does account for records with null asset tags. Option C is wrong because the script handles the scenario when no asset tag exists by generating a default tag (e.g., 'ASSET001'), so it does not fail in that case.

Full explanation →
389
MCQhard

A team is using a SOAP web service integration. The response contains namespaced XML, and the script that parses it is not extracting values correctly. What is the most likely issue?

A.WSDL caching prevents updated endpoint
B.SOAP version mismatch between request and response
C.HTTP timeout during response retrieval
D.Missing or incorrect namespace prefix handling in the script
AnswerD

Namespaces must be resolved correctly to access elements.

Why this answer

Namespaced XML requires proper namespace prefix handling to extract values; if the script lacks or mismatches prefixes, parsing fails. Option A is incorrect because WSDL caching affects endpoint updates, not parsing. Option B is incorrect because SOAP version mismatch typically causes communication errors, not parsing issues.

Option C is incorrect because HTTP timeout would result in no response, not incorrect value extraction.

Full explanation →
390
Multi-Selecteasy

Which THREE statements are true about database views in ServiceNow?

Select 3 answers
A.Database views can have fields from multiple tables
B.Database views can reference tables from different instances or databases
C.A database view can be used as a source for reports
D.Database views are read-only
E.Database views can be updated via business rules
AnswersA, C, D

Views can join multiple tables and include fields from each.

Why this answer

Options A, C, and D are correct. Database views are read-only (D), can combine fields from multiple tables (A), and can be used as a source for reports (C). Option B is false because database views cannot reference tables from different instances or databases; they can only combine tables within the same instance.

Option E is false because database views are read-only and cannot be updated via business rules.

Full explanation →
391
MCQeasy

Which script function is used to query the database in a business rule?

A.GlideRecord.query();
B.new GlideRecord('table').query();
C.gs.query();
D.GlideRecord.newQuery();
AnswerB

Correct; this creates a GlideRecord object and queries the table.

Why this answer

In ServiceNow, a business rule must instantiate a new GlideRecord object using the 'new' keyword and then call the query() method on that instance to retrieve records from the database. The syntax 'new GlideRecord('table').query()' properly creates a GlideRecord object for the specified table and executes the query to fetch matching records.

Exam trap

ServiceNow often tests the distinction between static class references and instance methods, so the trap here is that candidates mistakenly think 'GlideRecord.query()' is valid because they confuse it with other static utility classes like 'GlideSystem' or 'GlideAggregate', forgetting that GlideRecord requires instantiation with 'new'.

How to eliminate wrong answers

Option A is wrong because 'GlideRecord.query()' is a static call on the class itself, not on an instance; GlideRecord is not a static utility class and query() must be called on an instantiated object. Option C is wrong because 'gs.query()' is not a valid function; the 'gs' object (GlideSystem) provides methods like gs.getUser() or gs.log(), but does not have a query() method for database operations. Option D is wrong because 'GlideRecord.newQuery()' is not a valid method; GlideRecord has no static 'newQuery' method, and the correct approach is to use 'new GlideRecord()' followed by '.query()'.

Full explanation →
392
Multi-Selecteasy

In ServiceNow Studio, which TWO elements can be created directly from the 'Create Application File' wizard? (Choose two.)

Select 2 answers
A.Flow
B.System Property
C.Update Set
D.Table
E.Business Rule
AnswersD, E

Tables are a common application file created in Studio.

Why this answer

The correct answers are D (Table) and E (Business Rule). In ServiceNow Studio, the 'Create Application File' wizard allows creation of various application files such as Tables, Business Rules, Client Scripts, etc. Update Sets (C) are not created as application files; they are containers for changes.

System Properties (B) are created via the sys_properties module. Flows (A) are created in Flow Designer, not directly from the 'Create Application File' wizard. Therefore, only Tables and Business Rules are among the options that can be created directly via that wizard.

Full explanation →
393
Multi-Selecthard

Which three actions require a business rule to be set to 'before' to work correctly? (Choose three.)

Select 3 answers
A.Sending an email notification
B.Deleting a record related to the current record
C.Setting a default value on a new record
D.Updating a field on the current record
E.Aborting the current transaction
AnswersC, D, E

Correct; defaults must be set before the record is saved.

Why this answer

Options C, D, and E are correct. C: Setting a default value on a new record must occur before the record is saved to the database. D: Updating a field on the current record must be done before the record is saved, because after save the record is already stored.

E: Aborting the current transaction must happen before the database write; in an after business rule, the transaction has already been committed. Options A (sending an email notification) and B (deleting a related record) can be performed in after business rules because they do not require modifying the record before it is saved.

Full explanation →
394
MCQmedium

A developer creates a Scheduled Job that runs daily and sends an email notification to a list of users. The job uses a Script Action to query the 'incident' table and sends an email if the count exceeds a threshold. However, the email is not being sent. What is the most likely cause?

A.The email notification is set to 'Inactive'.
B.The Scheduled Job is configured to run on a different schedule than expected.
C.The user who created the job does not have the 'email_send' role.
D.There is a script error in the Script Action that prevents the email from being sent.
AnswerD

A script error would cause the action to fail silently, and no email is sent.

Why this answer

The most likely cause of the email not being sent is a script error in the Script Action. If the script encounters an error (e.g., a syntax error, a null reference, or a failed query), it will stop execution before reaching the email-sending logic, and the email will not be sent. Scheduled Jobs in ServiceNow execute scripts in a headless environment, and any unhandled exception will silently fail without sending the email.

Exam trap

The trap here is that candidates may assume the email notification's active state (Option A) is the cause, but the question specifies a Script Action directly sending the email, not a notification record, so the notification's state is irrelevant.

How to eliminate wrong answers

Option A is wrong because if the email notification were inactive, the Scheduled Job would still execute, but the notification record would not fire; however, the question states the email is not being sent, and the job uses a Script Action to send the email directly (likely via `gs.email.send()`), not via a notification record, so the notification's active state is irrelevant. Option B is wrong because if the job were running on a different schedule, it would still send the email when it does run; the issue is that the email is never sent, not that it runs at the wrong time. Option C is wrong because the `email_send` role is required to send email via `gs.email.send()` in a background script, but the Scheduled Job runs as the user who created it; if that user lacks the role, the script would throw a security exception, which is a script error, making D the more direct and likely cause.

Full explanation →
395
MCQeasy

When configuring a Service Portal page, a developer wants to ensure that a specific widget appears only to users with the 'itil' role. Which approach should be used?

A.Pass a role check from the server script to the client controller via widget options.
B.Write an Access Control Rule (ACL) on the widget's table to restrict access.
C.Set the 'Roles' property on the widget instance within the page designer.
D.Create a UI Policy on the portal table that hides the widget based on user roles.
AnswerC

The Roles property restricts widget visibility to specified roles.

Why this answer

The 'Roles' property on a widget instance within the Service Portal page designer directly controls which roles can view that specific widget. This is the intended declarative approach for role-based visibility at the widget instance level, without requiring custom scripting or ACLs.

Exam trap

The trap here is that candidates often confuse ACLs (which control data access) with widget instance visibility, or incorrectly think UI Policies can be applied to portal widgets, when in fact the 'Roles' property is the dedicated mechanism for this exact use case.

How to eliminate wrong answers

Option A is wrong because passing a role check from server script to client controller via widget options is an unnecessarily complex and non-standard approach; the platform provides the built-in 'Roles' property for this purpose. Option B is wrong because Access Control Rules (ACLs) on the widget's table control CRUD operations on the widget record itself, not the runtime visibility of the widget instance on a portal page. Option D is wrong because UI Policies operate on form fields and records, not on Service Portal widgets; they cannot be applied to portal tables to hide widget instances.

Full explanation →
396
MCQhard

A UI Policy with the above condition script never evaluates to true. What is the issue?

A.The condition must be written in AngularJS to work in UI16.
B.The property name is misspelled as 'my.property' but should be 'my_property'.
C.gs.getProperty() is not permitted in UI Policy scripts.
D.The script should not be wrapped in a function; it should directly be the condition expression.
AnswerD

UI Policy condition scripts are evaluated as the script itself, not a function call.

Why this answer

UI Policy condition scripts are evaluated as expressions; they should directly return the condition result without being wrapped in a function. The script must be a single expression that evaluates to true or false. Option A is incorrect because UI16 does not require AngularJS for UI Policy conditions; UI Policy conditions are still evaluated as standard scripts.

Option B is incorrect because there is no evidence of a misspelling, and property names can contain dots. Option C is incorrect because gs.getProperty() is permitted and commonly used in UI Policy scripts.

Full explanation →
397
MCQhard

The transform map fails when the source field 'u_summary' is null. What is the best way to prevent this error?

A.Use target.short_description = source.u_summary instead
B.Add a null check before setting: if(source.u_summary) target.setValue('short_description', source.u_summary);
C.Add a 'return true;' statement at the end
D.Map to a system field like 'sys_created_by'
AnswerB

Null check prevents the script from erroring when the source field is empty.

Why this answer

It adds a null check before setting the value, preventing the transform map from failing when source.u_summary is null. Option A is incorrect because it does not handle null, which would still cause an error. Option C is incorrect because 'return true;' does not address null values.

Option D is incorrect because mapping to a system field like 'sys_created_by' avoids the null issue but is not the best practice; using a null check is the appropriate approach.

Full explanation →
398
Multi-Selecteasy

Which TWO are best practices for designing forms in ServiceNow to enhance user experience and maintainability?

Select 2 answers
A.Leverage related lists to display one-to-many relationships on a form.
B.Always enable the 'Use Default Form' checkbox to ensure consistency.
C.Use a single form layout for all record types to reduce complexity.
D.Group related fields using sections to organize the form logically.
E.Avoid using reference fields on forms as they slow down performance.
AnswersA, D

Related lists provide a clear overview of child records directly on the parent form.

Why this answer

Options A and D are correct. A: Leveraging related lists is a best practice for displaying one-to-many relationships on a form, enhancing user access to related records. D: Grouping related fields into sections improves form readability and logical organization.

Option B is incorrect because always enabling the 'Use Default Form' checkbox is not a universal best practice; it depends on context. Option C is incorrect because using a single form layout for all record types may not suit varying needs and can reduce usability. Option E is incorrect because reference fields are essential for relational data and do not inherently slow down performance.

Full explanation →
399
MCQhard

A script include has a function that uses the 'GlideRecordSecure' class. When called from a Business Rule in a different scope, it throws a security exception. What is the most likely cause?

A.The script include does not have the 'Accessible from' property set to all scopes.
B.The function is not defined as a static function.
C.The GlideRecordSecure class is not accessible from other scopes.
D.The script include is not marked as public.
AnswerA

Must be set to 'All scopes' or specific scope.

Why this answer

The 'Accessible from' property on a Script Include controls which scopes can invoke its functions. When this property is not set to 'All scopes', a Business Rule in a different scope cannot call the Script Include, resulting in a security exception. The GlideRecordSecure class itself is accessible across scopes, but the Script Include's access restriction prevents the call.

Exam trap

ServiceNow often tests the misconception that GlideRecordSecure is the cause of cross-scope access issues, when in fact the Script Include's 'Accessible from' property is the primary gatekeeper for cross-scope invocation.

How to eliminate wrong answers

Option B is wrong because static functions are not required for cross-scope access; the 'Accessible from' property is the key control. Option C is wrong because the GlideRecordSecure class is accessible from other scopes by default; the issue is the Script Include's access restriction, not the class. Option D is wrong because marking a Script Include as 'public' (via the 'Accessible from' property) is exactly what is missing; the term 'public' in this context refers to the 'Accessible from' setting, not a separate flag.

Full explanation →
400
MCQhard

A company is using ServiceNow for incident management. They have a business rule on the 'before update' of the incident table that automatically assigns the incident to the first available member of the 'Support' group when the state changes to 'New'. The business rule works correctly when an incident is first created with state 'New', but when an existing incident's state is changed to 'New' from another state, the assignment does not happen. The business rule script checks if current.state.changesTo('New') and then queries the group members. The group has multiple members. Other business rules that run on state changes work fine. What is the most likely cause?

A.The condition current.state.changesTo('New') only works on insert, not on update.
B.A subsequent business rule that runs after this one in the same order is clearing the assignment field.
C.The business rule should be set to run on 'after' update instead of 'before' to ensure the state is committed.
D.The script uses current.assignment_group which is not available on update because the group might be different.
AnswerB

If another business rule runs after and sets assignment to empty, it would overwrite the assignment made by this rule.

Why this answer

The business rule runs on 'before update', and if a subsequent business rule in the same execution order clears the assignment field after this rule sets it, the assignment will be lost. This is a common issue when multiple business rules interact on the same table and order of execution matters. The fact that other state-change business rules work fine indicates the logic itself is sound, but a later rule is overriding the assignment.

Exam trap

The trap here is that candidates often assume changesTo() has a limitation on update, when in reality the issue is the order of execution and interaction between multiple business rules, which is a common pitfall in ServiceNow development.

How to eliminate wrong answers

Option A is wrong because current.state.changesTo('New') works on both insert and update; it returns true when the state field is changing to 'New' during an update, and it also works on insert (though on insert the 'from' value is null). Option C is wrong because running on 'after' update would not fix the issue; the assignment would still be cleared by a subsequent rule, and 'before' is actually the correct timing to set a field before it is saved. Option D is wrong because current.assignment_group is available on update; the group field is not read-only and can be accessed and set in both before and after business rules.

Full explanation →
401
MCQhard

A multinational corporation uses a single ServiceNow instance for IT service management. The ServiceNow portal serves thousands of users across multiple departments (HR, Finance, IT, Legal). Each department requires a customized portal experience: specific branding, tailored service catalog, and unique knowledge bases. The current implementation uses a single portal with multiple widgets that conditionally display content based on user group membership. Users have reported slow page loads and inconsistent styling across departments. The ServiceNow administrator must redesign the portal architecture to improve performance and maintainability while accommodating each department's requirements. Which approach should the administrator take?

A.Maintain a single portal but leverage ServiceNow's branding records and theme variants to apply department-specific styling; optimize widgets with client-side caching and lazy loading.
B.Create a separate portal for each department, each with its own theme and set of widgets to fully isolate customizations.
C.Standardize all departments onto a single, simple portal with no customizations to reduce complexity and improve load times.
D.Keep one portal with a single theme and use extensive client scripts to alter styling and content based on the user's department.
AnswerA

This approach centralizes portal management while allowing tailored experiences; caching and lazy loading improve performance.

Why this answer

By maintaining a single portal and using ServiceNow's branding records and theme variants, the administrator can apply department-specific styling centrally without fragmentation. Optimizing widgets with client-side caching and lazy loading addresses performance issues. Option B is incorrect because creating separate portals per department leads to significant maintenance overhead and configuration fragmentation.

Option C is incorrect because standardizing without customization ignores departmental requirements, resulting in poor user experience. Option D is incorrect because extensive client scripts for styling and content are inefficient, difficult to maintain, and still degrade performance.

Full explanation →
402
Drag & Dropmedium

Drag and drop the steps to create a new Notification in ServiceNow into the correct order.

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

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

The sequence: navigate to Notifications, create new, set table and name, define conditions, configure email details, and submit.

Full explanation →
403
MCQmedium

A company is building a ServiceNow application to manage employee onboarding. They need to store personal data like social security numbers (SSNs) and medical information. Which data classification scheme should they apply to these fields to ensure proper encryption and access controls?

A.Confidential
B.Internal
C.Highly Confidential
D.Public
AnswerC

Correct, this is the highest classification for sensitive personal data.

Why this answer

'Highly Confidential' is the ServiceNow data classification level designed for sensitive personal data such as social security numbers and medical information. This classification enforces mandatory encryption at rest and in transit, strict role-based access controls, and audit logging, aligning with regulatory requirements like GDPR and HIPAA.

Exam trap

The trap here is that candidates often confuse 'Confidential' with 'Highly Confidential', assuming that any sensitive data falls under 'Confidential', but ServiceNow reserves 'Highly Confidential' specifically for data requiring the highest security controls, such as PII and PHI.

How to eliminate wrong answers

Option A is wrong because 'Confidential' is a lower classification intended for business-sensitive data (e.g., internal financial reports) that does not require the same level of encryption and access restrictions as personal identifiable information (PII) or protected health information (PHI). Option B is wrong because 'Internal' is used for data that can be shared within the organization without special controls, such as standard operating procedures, and does not mandate encryption or granular access controls. Option D is wrong because 'Public' is for data that can be freely disclosed, like marketing materials, and has no security or encryption requirements.

Full explanation →
404
MCQmedium

A developer is building a scoped application in Studio that needs to access global records. Which application property should be enabled?

A.Allow access to this application from all scopes.
B.Allow access to all scoped applications.
C.Allow read/write access to tables in global scope.
D.Export table data.
AnswerC

Correct. This enables access to global tables.

Why this answer

Enabling 'Allow read/write access to tables in global scope' allows a scoped application to access global records. Option A is incorrect as it controls access from other scopes, not access to global tables. Option B is incorrect because it allows the application to be accessed by other scoped applications, not to access global tables.

Option D is for exporting table data, not for granting access to global tables.

Full explanation →
405
Drag & Dropmedium

Drag and drop the steps to create a new table in ServiceNow into the correct order.

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

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

The order is: navigate to tables, click new, define table properties, set attributes, then submit.

Full explanation →
406
Matchingmedium

Match each ServiceNow acronym to its definition.

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

Concepts
Matches

Configuration Management Database

Customer Service Management

IT Service Management

Human Resources Service Delivery

Governance, Risk, and Compliance

Why these pairings

Correct matches are ITSM: IT Service Management, ITOM: IT Operations Management, ITBM: IT Business Management, and CSM: Customer Service Management. Common confusions occur between ITSM and ITOM definitions.

Full explanation →
407
MCQeasy

A company needs to store data about employee certifications. Each employee may have multiple certifications. Which approach is best practice?

A.Add a multi-select field to the User table to store certification IDs
B.Create a new custom table with a reference field to the User table
C.Extend the User table to store certification fields directly
D.Create a database view that joins User and certification data
AnswerB

A new custom table with a reference to the User table is the best practice because it allows multiple certification records per employee, avoids inheriting unnecessary fields, and maintains relational integrity.

Why this answer

Creating a new table with a reference field to the User table allows storing multiple certification records per employee without adding unnecessary fields. Option A is wrong because a multi-select field on the User table cannot effectively store multiple certification records and lacks relational integrity. Option C is wrong because extending the User table would add many unwanted fields from the User table and complicate data management.

Option D is wrong because database views are read-only and cannot be used for storing data.

Full explanation →
408
MCQmedium

A company is integrating with an external HR system using a REST API to create and update user records in the sys_user table. The API endpoint requires a token that expires every 24 hours. The integration is scheduled to run hourly. The token is stored in a credential record. After a few days, the integration fails with a 401 Unauthorized error. The error log shows "Invalid token". What is the most likely cause?

A.The token was refreshed but the credential record was not updated.
B.The REST API endpoint URL changed.
C.The credential record was deleted.
D.The IP address of the external system changed.
AnswerA

The token expires; the integration uses the stored token. If the token is refreshed externally but not stored, the old token remains and becomes invalid after 24 hours.

Why this answer

The token expires every 24 hours, so after the first day, the stored token becomes invalid. The integration runs hourly and likely attempts to refresh the token, but if the refreshed token is not saved back to the credential record, the old token persists and causes the 401 error. Option A is correct because the most likely cause is that the token was refreshed but the credential record was not updated.

The other options are less likely: there's no evidence the URL changed (B), the credential record was deleted (C), or the IP changed (D).

Full explanation →
409
Multi-Selecthard

Which THREE are true about Data Policies? (Choose three.)

Select 3 answers
A.They can be used to enforce field requirements.
B.They can reference the current record's values.
C.They can fire on insert only.
D.They can be applied to specific user roles.
E.They run on the client side only.
AnswersA, B, D

Data policies can make fields mandatory or read-only based on conditions.

Why this answer

The correct answers are A, B, and D. Data Policies enforce field requirements (mandatory/read-only) on the server side, can reference current record values using conditions, and can be restricted to specific user roles via the 'Roles' condition. They do not run on the client side only; they execute server-side.

They can fire on both insert and update, not just insert.

Full explanation →
410
MCQmedium

Refer to the exhibit. The business rule is intended to update the CI's operational status when an incident is resolved. However, the CI is not being updated. What is the most likely reason?

A.The business rule runs after the record is saved, so changes to the CI are not saved
B.The script does not include a condition to check if the CI belongs to the cmdb_ci_server table
C.The business rule runs synchronously, so it cannot update another record
D.The script uses gr.update() without checking if the CI record exists
AnswerB

If the CI is not a server, the GlideRecord may fail to find it.

Why this answer

The script uses `gr.get('cmdb_ci_server', current.cmdb_ci)` which only finds CI records of the 'cmdb_ci_server' table. If the CI belongs to a different class (e.g., 'cmdb_ci_router'), the query returns no record, so the update never occurs. Option B is correct because the script lacks a condition to verify the CI's table class.

Option A is incorrect because business rules running after save can still update other records. Option C is false since synchronous rules can update other records. Option D is not the root cause; the `gr.update()` is present, but the problem is that the record is not found.

Full explanation →
411
Multi-Selecthard

Which THREE of the following are true about ACLs (Access Control Lists)? (Choose three.)

Select 3 answers
A.ACLs can include conditions that must be met for access.
B.ACLs are evaluated on the client side.
C.ACLs are only applicable to system tables.
D.ACLs can control read and write access to records.
E.ACLs can be scoped to a specific application.
AnswersA, D, E

Conditions can be added to ACLs.

Why this answer

ACLs (Access Control Lists) in ServiceNow are used to enforce security by specifying conditions that must be met for a user to access a record, field, or script. Option A is correct because an ACL defines a condition (typically a script or a set of conditions) that evaluates to true or false, and only when the condition is met is access granted or denied. This is the core mechanism of ServiceNow's role-based and condition-based access control.

Exam trap

ServiceNow often tests the misconception that ACLs are client-side or only apply to system tables, but in ServiceNow, ACLs are server-side and apply to all tables, including custom and scoped application tables.

Full explanation →
412
MCQhard

A developer needs to create a new application scope. Which of the following is a best practice when defining the scope?

A.Set the application's access level to 'Protected' to prevent other applications from modifying its records.
B.Use the global scope to avoid access restrictions.
C.Use a scope name that is already in use to leverage existing configurations.
D.Create the scope and later change the name if needed.
AnswerA

Setting the scope to 'Protected' is not possible; 'Protected' is an application-level access setting, not a scope property.

Why this answer

When defining a new application scope, setting the application's access level to 'Protected' is considered a best practice. This restricts access to the application's resources, preventing other applications from modifying its records. The scope name should be unique and not changed after creation.

Using the global scope (B) should be avoided for custom applications, reusing an existing scope name (C) is not allowed, and changing the scope name after creation (D) can cause configuration issues.

Exam trap

Candidates often confuse 'Protected' with 'Private', assuming it blocks all access. They may also mistakenly believe that using the global scope is the safest choice to avoid access restrictions, when in fact it exposes the application to unauthorized modifications from other scopes.

How to eliminate wrong answers

Option B is wrong because using the global scope exposes the application's records to modification by any other application, undermining data integrity and security. Option C is wrong because scope names must be unique within an instance; reusing an existing scope name would cause a conflict and is not permitted. Option D is wrong because the scope name is immutable after creation; it cannot be changed later without recreating the application, which would break existing references and configurations.

Full explanation →
413
Multi-Selectmedium

A developer is troubleshooting an issue where a business rule is not firing. Which TWO steps should the developer take to diagnose the problem? (Choose two.)

Select 2 answers
A.Check the business rule order.
B.Ensure the business rule has a condition.
C.Run the business rule from the context menu.
D.Verify that the business rule is active.
E.Check if the table is locked.
AnswersB, D

If the condition evaluates to false, the rule does not run.

Why this answer

Options B and D are correct. To diagnose why a business rule is not firing, the developer should first verify that the business rule is active (D) and ensure it has a condition that evaluates to true (B). Checking the order (A) is only relevant when multiple business rules conflict, not a primary diagnostic step.

Business rules cannot be run manually (C is incorrect), and table locking (E) is not related to business rule execution.

Full explanation →
414
MCQeasy

This client script is attached to the 'category' field on the incident form. When the user changes the category to 'Network', what happens to the short_description field?

A.Nothing happens because newValue equals 'Network' which passes the empty check.
B.The short_description is set to 'Category changed to Network'.
C.An error occurs because setValue cannot be called with a string.
D.The short_description is cleared.
AnswerB

The setValue method updates the field.

Why this answer

The client script checks if the newValue of the 'category' field is not empty and equals 'Network'. When the user changes the category to 'Network', newValue is 'Network', which passes the empty check (newValue !== ''), and then the condition newValue === 'Network' is true. The script then executes g_form.setValue('short_description', 'Category changed to Network'), which sets the short_description field to that string.

Exam trap

The trap here is that candidates may misinterpret the empty check as a guard that prevents any action when newValue is non-empty, but the script only skips if newValue is empty, so when newValue is 'Network', it proceeds to the equality check and executes the setValue call.

How to eliminate wrong answers

Option A is wrong because the empty check (newValue !== '') passes when newValue is 'Network', so the script does not skip execution; it proceeds to the equality check. Option C is wrong because g_form.setValue() can accept a string as the second argument; it sets the field value to that string without error. Option D is wrong because the script explicitly sets the short_description to 'Category changed to Network', not clearing it; clearing would require an empty string or null.

Full explanation →
415
Multi-Selecthard

Which TWO of the following are valid methods to authenticate a REST API call to ServiceNow?

Select 2 answers
A.SAML assertion authentication.
B.LDAP authentication.
C.Basic Authentication with username and password.
D.API Key authentication.
E.OAuth 2.0 authentication.
AnswersC, E

Basic Authentication is supported.

Why this answer

ServiceNow supports Basic Authentication, where the REST API call includes an HTTP Authorization header with a Base64-encoded string of 'username:password'. This is a straightforward method for authenticating API requests, though it requires HTTPS to avoid exposing credentials in plaintext.

Exam trap

The trap here is that candidates may confuse authentication methods supported for the UI (like SAML or LDAP) with those valid for REST API calls, or mistakenly think ServiceNow supports API keys when it does not.

Full explanation →
416
Multi-Selecthard

Which TWO are common issues when troubleshooting a failed LDAP import?

Select 2 answers
A.LDAP filter syntax is invalid
B.OAuth token for LDAP is expired
C.LDAP attribute mapping does not match target fields
D.Base DN is incorrectly specified
E.LDAP server is unreachable
AnswersA, D

Invalid filters cause the import to retrieve no data or error.

Why this answer

Options A and D are correct. A: Invalid LDAP filter syntax is a common issue because it can cause no results or errors during import. D: Incorrectly specified Base DN is also a frequent misconfiguration that prevents the import from locating the correct directory entries.

B: OAuth token expiry is not relevant to LDAP imports; LDAP typically uses simple bind or certificate. C: Attribute mapping mismatches can occur but are less common than filter or Base DN issues. E: LDAP server unreachable is a connectivity problem, but filter and Base DN are more specific to import failures.

Full explanation →
417
MCQeasy

An import set is failing because some records have duplicate values in a unique field. The requirement is to skip duplicates and import only new records. Which transform map option should be used?

A.Enable 'Import set update only' in the transform map.
B.Enable 'Update existing records' in the transform map.
C.Enable 'Reject duplicates' in the data source options.
D.Enable 'Coalesce' on the unique field and set 'Action' to 'Insert' in the transform map.
AnswerD

Coalesce identifies existing records, and setting action to Insert ensures new records are created and duplicates are ignored.

Why this answer

Coalesce on the unique field allows the transform map to identify existing records by matching the incoming field to a unique field in the target table. Setting the Action to 'Insert' ensures that only new records are imported; if a match is found, the record is skipped (since it already exists). Option A ('Import set update only') is not a standard option in ServiceNow.

Option B ('Update existing records') would update duplicates rather than skip them. Option C ('Reject duplicates') is not a typical option in data sources; the correct approach is using coalesce with Insert action.

Full explanation →
418
MCQmedium

A developer needs to create a script that runs before a record is inserted, to set a default value. Which business rule 'When' option is appropriate?

A.Before
B.Async
C.After
D.Display
AnswerA

Correct; before insert allows modifying the record before save.

Why this answer

(Before) is correct because 'Before' business rules run before the record is saved to the database, allowing default values to be set. Option B (Async) is incorrect because Asynchronous rules run later in a separate transaction. Option C (After) is incorrect because 'After' rules run after the record is already saved, so they cannot set default values before insert.

Option D (Display) is incorrect because 'Display' rules run when the form is loaded, not before insert.

Full explanation →
419
MCQeasy

A company wants to display a list of open incidents on a Service Portal page. Which component should be used?

A.Map widget
B.Data Table Widget
C.Performance Analytics widget
D.List View Widget
AnswerB

Data Table Widget is the standard component for displaying lists of records in Service Portal.

Why this answer

The Data Table Widget is the standard component for displaying lists of records in Service Portal, making option B correct. Option A (Map Widget) is used for geospatial data. Option C (Performance Analytics widget) is for analytics dashboards.

Option D (List View Widget) is designed for the backend UI, not for portals.

Full explanation →
420
MCQhard

An organization uses ServiceNow Discovery to populate the CMDB. They notice that some CI relationships are missing after a discovery run. The discovery logs show no errors. What is the most likely cause?

A.The MID server credentials do not have permission to query relationship data
B.The CI Class Manager does not have the correct relationship types defined for the discovered CIs
C.The discovery probes are not configured to capture relationships
D.The CMDB is set to read-only mode
AnswerB

The CI Class Manager defines which relationships are possible between CI classes. If a relationship type is missing, it won't be created.

Why this answer

The CI Class Manager defines which relationship types are valid for each CI class. If the relationship types are not defined or incorrectly configured, Discovery will not create those relationships even if the probes run successfully and no errors are logged. The absence of errors indicates the discovery process completed normally, but the missing relationships are due to missing or incorrect relationship definitions in the CI Class Manager.

Exam trap

The trap here is that candidates assume missing relationships must be caused by a probe or permission issue, overlooking that the CI Class Manager's relationship definitions are a prerequisite for relationship creation, even when discovery runs without errors.

How to eliminate wrong answers

Option A is wrong because MID server credentials are used for authentication to target systems; if they lacked permission to query relationship data, the discovery logs would typically show authentication or permission errors, not a clean run with no errors. Option C is wrong because discovery probes are configured to capture CIs and their attributes, but relationships are not captured by probes directly; they are inferred by the Discovery engine based on relationship types defined in the CI Class Manager. Option D is wrong because a read-only CMDB would prevent any updates to the CMDB, including CI creation and relationship creation, and would generate errors or warnings in the logs, not a clean run with missing relationships.

Full explanation →
421
Multi-Selectmedium

Which TWO statements are true about GlideAggregate?

Select 2 answers
A.It uses getRowCount() to retrieve the count.
B.It can only be used with sys_id fields.
C.It provides methods like addAggregate and getAggregate.
D.It extends the GlideRecord class.
E.It can aggregate data across multiple tables in a single query.
AnswersC, D

Correct: These are key methods for aggregation.

Why this answer

Options C and D are correct. GlideAggregate extends the GlideRecord class (D) and provides methods like addAggregate and getAggregate (C) for performing aggregate queries on database tables. Option A is incorrect because getRowCount() is a method of GlideRecord, not the primary method for retrieving counts; GlideAggregate uses addAggregate('COUNT', 'field') and getAggregate() instead.

Option B is incorrect because GlideAggregate can be used with any field, not just sys_id. Option E is incorrect because GlideAggregate works on a single table per query; to aggregate across multiple tables, you would need separate queries or database views.

Full explanation →
422
MCQeasy

A developer needs to expose a custom table's data via REST API in ServiceNow Studio. Which approach should they use?

A.Configure a REST API from the system Web Services menu.
B.Create a Scripted REST API in Studio.
C.Generate an API from the Application Menu.
D.Use the table API directly without any configuration.
AnswerB

Correct. Studio provides a template for Scripted REST APIs.

Why this answer

The correct approach is to create a Scripted REST API in Studio (Option B). Studio provides a dedicated module for building custom REST APIs that can expose table data. Option A is incorrect because the system Web Services menu is not part of Studio and is used for configuring base REST APIs, not custom ones.

Option C is wrong because generating an API from the Application Menu is not a standard Studio feature. Option D is incorrect because the table API requires additional configuration (ACLs) and is not directly accessible without setting up an endpoint.

Full explanation →
423
Multi-Selectmedium

A developer is investigating why an outbound REST message is not sending data correctly. Which TWO actions should the developer check first? (Choose two.)

Select 2 answers
A.Restart the web server.
B.Reinstall the ServiceNow instance.
C.Review the script include for errors.
D.Check the authentication profile.
E.Verify the endpoint URL.
AnswersD, E

Invalid credentials or configuration can prevent sending.

Why this answer

The most immediate checks are the endpoint URL to ensure it is correct, and the authentication profile to ensure credentials are valid. These are common causes of failures.

Full explanation →
424
MCQhard

A developer is designing a solution to allow users to request access to specific applications through a Service Catalog. Each application can be requested by multiple users, and each user can request multiple applications. The request must capture the user's business justification and the date needed. The developer needs to model the data. Which database schema design best adheres to ServiceNow best practices?

A.Add a string field on the Application table that stores a comma-separated list of user sys_ids
B.Add a multi-reference field on the User table that lists all requested applications
C.Create a custom table 'u_application_request' with fields: user (reference to sys_user), application (reference to custom application table), justification (string), date_needed (date)
D.Create one table for all requests with a reference to both user and application, but store justification and date needed separately in a different table
AnswerC

Correct; a dedicated M2M table with additional attributes models the relationship and captures extra data.

Why this answer

It creates a dedicated 'u_application_request' table with reference fields to both sys_user and the custom application table, plus justification and date_needed fields. This models the many-to-many relationship properly with additional attributes, adhering to ServiceNow best practices of using reference fields for relationships and avoiding unstructured data storage.

Exam trap

The trap here is that candidates often choose Option D thinking it follows 'separation of concerns' by splitting data into multiple tables, but ServiceNow best practices favor a single table for all attributes of a relationship to maintain simplicity and query performance.

How to eliminate wrong answers

Option A is wrong because storing comma-separated user sys_ids in a string field violates normalization principles, makes querying and reporting inefficient, and breaks referential integrity. Option B is wrong because a multi-reference field on the User table can list applications but cannot capture additional attributes like justification and date_needed, and it creates an asymmetric relationship that complicates maintenance. Option D is wrong because storing justification and date_needed in a separate table from the request association introduces unnecessary complexity and fragmentation, violating the principle of keeping related data together in a single table.

Full explanation →
425
MCQeasy

Refer to the exhibit. The developer expects a list of incidents in the widget, but the page renders with an error. What is the most likely cause?

A.The server script is missing a return statement
B.getRow() is not a valid method on GlideRecord
C.The query does not filter for active incidents
D.The data.items array is not initialized correctly
AnswerB

Correct: getRow() is not a GlideRecord method; it causes a script error.

Why this answer

The error occurs because getRow() is not a valid method on GlideRecord. The correct method to access field values from a GlideRecord object is getValue(). Option A is not the most likely cause because server scripts do not require an explicit return statement; the data structure is implicitly returned.

Option C is a logic issue, not a syntax error. Option D is incorrect because the data.items array is correctly initialized with new Array() or [] and then pushed in the loop.

Full explanation →
426
Multi-Selecthard

Which THREE statements are correct about script includes and their usage across scopes? (Select THREE)

Select 3 answers
A.A script include can be accessed from a Business Rule in a different scope if the script include is defined as a global script include.
B.Script includes defined as 'public' can be accessed from any scope without restriction.
C.A script include must be marked as 'public' to be accessible from other scopes.
D.To call a script include from another scope, you must use the global scope prefix.
E.The 'Accessible from' property can be set to 'All scopes' or specific scopes.
AnswersA, C, E

Global script includes are accessible.

Why this answer

Script includes in ServiceNow are isolated by scope by default. To make a script include accessible from a business rule in a different scope, it must be defined as a global script include (i.e., its scope is set to 'Global'). This allows the script include to be referenced and executed from any scope without requiring the global scope prefix.

Exam trap

The trap here is that candidates often confuse the 'public' access modifier from other programming languages with ServiceNow's 'Accessible from' property, leading them to select option B as correct.

Full explanation →
427
MCQhard

A company wants to create a custom homepage for their service portal that displays three different data sources in a single view. The design must ensure that if one data source fails to load, the other two continue to function. Which implementation approach aligns best with this requirement?

A.Use a parent widget that calls three child widgets
B.Use three separate widgets each fetching their own data
C.Use a widget that loads data in parallel with error handling
D.Use a single widget that fetches all data sequentially
AnswerB

Correct: Separate widgets run independently, so one failure does not affect others.

Why this answer

Using three separate widgets isolates failures. Options A, C, and D can cause cascading failures. Option B ensures independence.

Full explanation →
428
MCQhard

A large enterprise manages its IT assets using a custom table 'u_asset_tracking', which includes a reference field 'u_location' pointing to the 'cmn_location' table. After a recent application upgrade, users report that the location is not being displayed for assets older than six months, although it works for newer assets. A client script uses GlideAjax to fetch the location via a Script Include called 'AssetUtils'. The Script Include performs a GlideRecord query on 'u_asset_tracking' and then dot-walks to 'u_location.sys_id' to retrieve the location name. The upgrade included changes to the application's access controls. The logs show no errors, but the Ajax call returns null for the location. What should the developer do to resolve this issue?

A.Modify the Script Include to use addNullQuery('u_location') to skip empty location fields.
B.Ensure the 'read' role on the 'cmn_location' table is granted to the application's scope or the user's role.
C.Change the client script to use a UI Policy instead of GlideAjax to handle the location display.
D.Write a fix script to update the 'u_location' field for all assets older than six months.
AnswerB

The upgrade likely changed ACLs; granting read access to 'cmn_location' for the appropriate scope or role resolves the null returns.

Why this answer

The issue is that after the upgrade, access controls (ACLs) were changed, and the Script Include's GlideRecord query dot-walks to 'cmn_location' to retrieve the location name. Even though the query on 'u_asset_tracking' succeeds, the dot-walk to 'cmn_location' fails silently because the script's execution context (or the user's session) lacks the 'read' role on the 'cmn_location' table. Granting the 'read' role ensures the GlideRecord can access the referenced record, resolving the null return.

Exam trap

The trap here is that candidates assume the issue is with the query logic or data integrity (options A or D) rather than recognizing that a silent ACL failure on a dot-walked table is a common post-upgrade problem, especially when no errors appear in logs.

How to eliminate wrong answers

Option A is wrong because addNullQuery('u_location') would filter out records where the location field is empty, but the problem is that the location is not being displayed for assets older than six months, not that the field is null; this would not fix the access control issue. Option C is wrong because a UI Policy runs client-side and cannot perform server-side GlideRecord queries to fetch location data; it would not replace the GlideAjax call that retrieves the location name. Option D is wrong because writing a fix script to update the 'u_location' field would not address the underlying access control restriction that prevents the dot-walk from reading the location record; the data is already correct but inaccessible.

Full explanation →
429
Drag & Dropmedium

Drag and drop the steps to create a UI Action in ServiceNow into the correct order.

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

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

The correct order: navigate to UI Actions, create new, define table and names, set conditions, script and submit.

Full explanation →
430
MCQeasy

The client script above runs on a text field's onChange event. When the user changes the field, the 'short_description' field is not updated. What is the most likely reason?

A.The script is missing a semicolon after the setValue statement.
B.The 'short_description' field is defined as read-only on the form.
C.g_form is not available in the onChange client script.
D.The script runs before the new value is assigned to the field.
AnswerB

g_form.setValue cannot modify read-only fields.

Why this answer

G_form.setValue() cannot update a read-only field. If 'short_description' is defined as read-only on the form, the script will fail to change its value. Option A is incorrect because a missing semicolon would not prevent the field update; JavaScript allows optional semicolons.

Option C is incorrect because g_form is available in onChange client scripts. Option D is incorrect because the onChange event fires after the new value is assigned to the field, so the script runs with the updated value.

Full explanation →
431
Multi-Selecthard

Which THREE considerations are important when designing a scoped application for a customer?

Select 3 answers
A.Minimize number of update sets.
B.Avoid modifying global tables directly.
C.Scope application name uniquely.
D.Use global Business Rules for performance.
E.Include only necessary features.
AnswersB, C, E

Correct. Modifying global tables can cause conflicts with other applications.

Why this answer

When designing a scoped application in ServiceNow, it is crucial to avoid modifying global tables directly (B) to prevent unintended side effects and maintain upgradeability. The application name must be uniquely scoped (C) to prevent conflicts with other applications. Including only necessary features (E) reduces complexity and improves performance.

Option A is incorrect because minimizing update sets is not a design consideration; update sets are for deployment management. Option D is incorrect because using global Business Rules contradicts the purpose of scoping and can cause cross-scope issues.

Full explanation →
432
MCQeasy

As a best practice, which method should be used to schedule recurring data imports from external sources?

A.Deploy an update set for each import
B.Use a Flow Designer flow with an HTTP trigger
C.Configure a scheduled job to use the Import Set API or transform
D.Create a business rule that triggers on a condition
AnswerC

Scheduled jobs are designed for recurring tasks like data imports.

Why this answer

A scheduled job can be configured to run at recurring intervals and use the Import Set API or transform to import data from external sources. Option A is incorrect because update sets are used for version control and deployment, not for scheduling data imports. Option B is incorrect because a Flow Designer flow with an HTTP trigger is designed for real-time HTTP requests, not for recurring scheduled imports.

Option D is incorrect because business rules trigger on database operations (like insert, update, delete) and are not suited for scheduling recurring imports.

Full explanation →
433
MCQhard

A large financial institution has a custom application for managing trade requests. The application uses a business rule on the 'Trade' table that calculates and sets the 'net_value' field based on 'quantity' and 'price'. Recently, traders have reported that when they update existing trades via a REST API integration, the 'net_value' field is not being recalculated. The business rule is set to run 'before' insert and 'before' update. The REST API uses GlideRecord to update the trade records. Upon investigation, the developer finds that the business rule script includes a check: 'if (current.changes('quantity') || current.changes('price')) { // recalculate }'. The script works correctly when updates are made from the UI. What is the most likely cause of the issue?

A.The business rule is set to run 'before' update, but the REST API triggers 'after' update.
B.The GlideRecord used in the REST API does not load the record's previous values, so changes() returns false.
C.The REST API sends the update request to a different instance, bypassing the business rule.
D.The condition 'current.changes('quantity') || current.changes('price')' is incorrectly formatted; it should use 'current.changes('quantity') || current.changes('price')'.
AnswerB

The changes() method relies on the previous values being loaded into the GlideRecord object. If the script creates a new GlideRecord and sets fields without first getting the record, or if the update is performed via a GlideRecord that hasn't been initialized with the old record, changes() may not detect changes.

Why this answer

The GlideRecord API used in REST API integrations does not automatically load the previous values of fields into the `changes()` method. When a record is updated via GlideRecord in a scripted REST API, the `current` object in the business rule does not have the 'previous' values populated, so `current.changes('quantity')` and `current.changes('price')` both return `false`. This causes the recalculation logic to be skipped, even though the business rule is set to run 'before update'.

In contrast, UI updates load previous values correctly, making `changes()` work as expected.

Exam trap

The trap here is that candidates assume `changes()` works universally in all update contexts, but ServiceNow specifically designed it to rely on the `previous` object, which is not populated in scripted REST API GlideRecord updates unless the record is explicitly loaded with `get()` before modification.

How to eliminate wrong answers

Option A is wrong because the business rule is set to run 'before update', and REST API updates still trigger 'before update' business rules; the issue is not about timing. Option C is wrong because REST API updates target the same instance where the business rule is defined; they do not bypass it unless explicitly routed elsewhere. Option D is wrong because the condition syntax is correct; the problem is not with the formatting of the condition but with the underlying data available to `changes()`.

Full explanation →
434
MCQmedium

A developer created a custom form section for the 'change_request' table that contains a reference field to 'cmdb_ci'. The section is visible in the form layout for all change request types. However, when the 'type' field is set to 'Emergency', the section should not be visible. The developer added a UI Policy to hide the entire section when type is 'Emergency'. But the section remains visible. After checking, the UI Policy is active and the condition is set correctly. What is the most likely reason the UI Policy is not working, and what is the best fix?

A.The section's 'Visible' checkbox in the form layout must be unchecked and then controlled by the UI Policy
B.UI Policies cannot hide form sections; they only control field-level visibility. The developer should hide each field in the section individually via UI Policy or use a client script to hide the section div
C.The UI Policy must be set to 'Run for all users' and the section must be assigned a 'visible' attribute
D.The UI Policy order is too low; it should be set to a higher priority number
AnswerB

This is the correct analysis and solution.

Why this answer

UI Policies in ServiceNow can only control the visibility of individual fields, not entire form sections. The developer must either hide each field in the section via separate UI Policy conditions or use a client script to hide the section's HTML div element. Option A is incorrect because UI Policies cannot directly target form sections.

Option C is incorrect because there is no 'visible' attribute to assign. Option D is incorrect because the issue is not about order or priority.

Full explanation →
435
MCQeasy

A company needs to import data from a CSV file into a custom table. The import should update existing records if a unique identifier matches, and insert new records if no match is found. Which feature should be configured on the transform map to achieve this?

A.Coalesce
B.Scheduled import
C.Field mapping
D.Data source
AnswerA

Coalesce is a transform map field property that determines whether the record is updated (if a match is found) or inserted.

Why this answer

The Coalesce feature on a transform map determines which field(s) are used to match incoming records against existing records in the target table. When a match is found, the transform map updates the existing record; when no match is found, it inserts a new record. This directly enables the required upsert behavior.

Exam trap

The trap here is that candidates often confuse Coalesce with field mapping, thinking that mapping fields alone handles the upsert, but Coalesce is the specific mechanism that triggers the update vs. insert decision.

How to eliminate wrong answers

Option B (Scheduled import) is wrong because it controls the timing of the import job, not the matching or update/insert logic. Option C (Field mapping) is wrong because it defines how source fields map to target fields but does not handle record matching or upsert decisions. Option D (Data source) is wrong because it defines the source of the data (e.g., file, database) and its connection details, not the merge logic.

Full explanation →
436
MCQhard

A ServiceNow instance has a custom table 'u_integration_log' that stores integration transactions. A flow in Flow Designer logs errors by creating records in this table. The flow is running with high volume, and the table is growing quickly causing performance issues. What is the best design to mitigate this?

A.Configure a scheduled job to archive and delete records older than 30 days.
B.Disable error logging in the flow.
C.Use a 'Log to file' action in the flow instead of a table.
D.Store logs in a separate instance via MID Server.
AnswerA

Regular cleanup balances data retention with performance.

Why this answer

It directly addresses the root cause of performance degradation—uncontrolled table growth—by implementing a scheduled job to archive and delete records older than 30 days. This reduces table size, improves query performance, and maintains the ability to retain recent logs for debugging. In ServiceNow, scheduled jobs can use GlideRecord to delete records based on a date condition, and archiving can be done via export to CSV or a separate archive table.

Exam trap

The trap here is that candidates may choose Option B (disable logging) thinking it's a quick fix, but the exam tests understanding that logging is essential for operations and that proper data lifecycle management (archiving/deletion) is the correct design pattern for high-volume tables.

How to eliminate wrong answers

Option B is wrong because disabling error logging entirely removes visibility into integration failures, which is critical for troubleshooting and monitoring; it does not solve the performance issue but instead eliminates the data needed for diagnostics. Option C is wrong because 'Log to file' action in Flow Designer writes to the instance's local file system, which is not a scalable or supported method for high-volume logging and does not provide the structured querying and retention capabilities of a table; it also does not address the underlying performance issue of table growth. Option D is wrong because storing logs in a separate instance via MID Server introduces unnecessary complexity, latency, and dependency on MID Server availability, and does not solve the immediate performance problem on the current instance; it is an over-engineered solution for simple log retention.

Full explanation →
437
MCQmedium

A company is redesigning its service catalog to improve user experience. One of the catalog items, 'Request New Software', contains 10 variables including software category, license type, and required approvals. The variable fields should dynamically show/hide and become mandatory based on previous selections. Currently, the catalog item uses a single, complex catalog client script that handles all visibility and mandatory conditions. This script has become difficult to maintain, and users experience delays when interacting with the form. The IT team wants a more efficient and maintainable solution. What should the administrator do?

A.Move the entire logic to a business rule that runs on the server side to reduce client-side processing.
B.Implement UI policies for visibility and mandatory conditions, and keep a streamlined catalog client script only for dynamic field values or complex calculations.
C.Convert all conditions to UI policies to replace the catalog client script entirely.
D.Refactor the existing catalog client script into a single, more efficient script with optimized conditions.
AnswerB

UI policies handle declarative conditions efficiently; client scripts supplement when needed, improving maintainability.

Why this answer

UI policies are the declarative way to handle field visibility and mandatory conditions in ServiceNow, making maintenance easier and improving performance by reducing client-side script execution. A streamlined catalog client script can still be used for complex dynamic value calculations that UI policies cannot handle. Option A is incorrect because business rules run server-side and cannot control client-side form behavior.

Option C is incorrect because UI policies cannot replace all client scripts; some complex logic still requires scripts. Option D is incorrect because a single complex script remains difficult to maintain and causes performance issues.

Full explanation →
438
Multi-Selecteasy

Which THREE are valid actions that can be performed by a Workflow Activity in Legacy Workflow Editor?

Select 3 answers
A.Run a script
B.Approve a record
C.Wait for condition
D.Create a record
E.Send an event
AnswersA, D, E

True; Run Script activity executes GlideRecord scripts.

Why this answer

The Legacy Workflow Editor includes a 'Run Script' activity that executes server-side JavaScript (GlideRecord, GlideSystem, etc.) within the workflow context. This allows custom logic such as data manipulation, condition checks, or API calls to be performed as part of the workflow flow.

Exam trap

ServiceNow often tests the exact naming of workflow activities; the trap here is that 'Wait for condition' (lowercase 'c') is not the official activity name—it is 'Wait for Condition'—and candidates may mistakenly select it as a valid action when the question expects only activities that perform an explicit action (like creating, sending, or running a script), not a passive wait state.

Full explanation →
439
MCQmedium

A developer wants to trigger a Business Rule on a child table when a parent record is updated. How can this be achieved?

A.Use a workaround with a scheduled job.
B.Add a condition on the child table's Business Rule referencing the parent.
C.This is not possible in ServiceNow.
D.Use a before query Business Rule on the child table.
AnswerB

Condition can check parent field changes.

Why this answer

A Business Rule on the child table can include a condition that checks whether a related parent record has been updated. This is done by referencing the parent table's fields via dot-walking (e.g., `current.parent_field.changes()`) or by querying the parent record's sys_updated_on field. The Business Rule runs on the child table when a child record is inserted or updated, and the condition evaluates the parent's state, allowing the rule to trigger logic based on parent changes without requiring a direct trigger on the parent table.

Exam trap

The trap here is that candidates assume a Business Rule can only be triggered directly on the table being updated, overlooking the ability to use conditions on related table records to react to parent changes.

How to eliminate wrong answers

Option A is wrong because using a scheduled job is an inefficient workaround that introduces latency and complexity; it is not the intended or recommended approach for reacting to parent updates in real time. Option C is wrong because it is indeed possible to achieve this behavior using a condition on the child table's Business Rule, as described in the correct answer. Option D is wrong because a before query Business Rule runs during query operations (retrieval), not on updates, and cannot be used to trigger logic when a parent record is updated.

Full explanation →
440
MCQmedium

A company has a business rule that should update the 'priority' field on the Incident table whenever the 'impact' field is changed to 'High'. However, the business rule is not firing. The business rule is set to run 'before' insert/update, with condition 'current.impact.changes()'. The 'impact' field is of type 'choice' with values 'Low', 'Medium', 'High'. Which of the following is the most likely cause?

A.The business rule is set to run 'after' instead of 'before'.
B.The script uses 'gs.addErrorMessage()' which stops execution.
C.The business rule is inactive.
D.The condition 'current.impact.changes()' returns false on insert because the previous value is null.
AnswerD

On insert, the previous value is null, so 'changes()' returns false. The condition should be modified to handle both insert and update.

Why this answer

The condition `current.impact.changes()` checks if the field value has changed from a previous value. On an insert, the previous value is null, so the condition returns false even when the impact is set to 'High'. This prevents the business rule from firing on insert, which is a common pitfall when using `changes()` without also checking for the new value.

Exam trap

ServiceNow often tests the subtle difference between `changes()` and `changesTo()` in business rules, where candidates mistakenly assume `changes()` works on insert when it only detects changes from a prior value.

How to eliminate wrong answers

Option A is wrong because the business rule is set to run 'before', which is appropriate for updating a field on the same record; running 'after' would still allow the update but is not the cause of the rule not firing. Option B is wrong because `gs.addErrorMessage()` does not stop script execution; it only adds a message to the user interface and the script continues. Option C is wrong because if the business rule were inactive, it would never fire, but the question states the rule is not firing under specific conditions, implying it is active.

Full explanation →
441
MCQhard

A developer creates a business rule that runs before a record is inserted or updated on the Incident table. The rule sets the assignment group based on the category. However, after the rule runs, the assignment group is not being saved. What is the most likely cause?

A.The rule is a display business rule
B.The rule runs after the record is saved
C.The business rule is set to run on before update only
D.The script does not use current.setAbortAction(false)
AnswerB

After business rules require an explicit current.update() to save changes.

Why this answer

The most likely cause is that the business rule is configured to run 'after' the record is saved (option B), even though the developer intended it to run 'before'. In a 'before' business rule, changes to fields on the current record are automatically saved when the record is committed. However, in an 'after' business rule, the record is already saved, so modifications to current are not persisted unless the script explicitly calls current.update().

Option A describes a display business rule, which runs client-side and does not affect server-side saving. Option C is unlikely because if it ran on before update only, it would still run before save. Option D is incorrect because setAbortAction(false) is used in 'before' rules to allow the save to proceed, not to persist changes.

Full explanation →
442
MCQmedium

A developer needs to create a business rule that runs only when the 'State' field of an Incident changes from 'New' to 'In Progress'. Which condition script should be used?

A.current.state.changes() && current.state.changesFrom('New')
B.current.state == 'New' && current.state.changesTo('In Progress')
C.current.state.changes() && previous.state == 'New'
D.current.state.changesTo('In Progress')
AnswerA

This correctly checks that the state changed and the previous value was 'New'.

Why this answer

It uses both `current.state.changes()` to verify the field has changed and `current.state.changesFrom('New')` to ensure the previous value was 'New'. This combination precisely captures the transition from 'New' to any other state, which when combined with the business rule's 'when to run' condition (set to 'In Progress' in the rule's filter or script), ensures the rule fires only when the state changes from 'New' to 'In Progress'.

Exam trap

The trap here is that candidates often pick Option D thinking `changesTo('In Progress')` alone is sufficient, forgetting that it does not restrict the previous state, so the rule would fire for any transition into 'In Progress', not just from 'New'.

How to eliminate wrong answers

Option B is wrong because `current.state == 'New'` checks the current value, not the previous value; this would incorrectly fire when the state is currently 'New' and changes to 'In Progress', which is impossible since the state cannot be both 'New' and changing to 'In Progress' at the same time. Option C is wrong because `previous.state == 'New'` only checks the previous value but does not verify that the new value is 'In Progress'; the rule would fire for any state change from 'New' (e.g., to 'Resolved' or 'Canceled'). Option D is wrong because `current.state.changesTo('In Progress')` alone does not ensure the previous state was 'New'; the rule would fire if the state changes to 'In Progress' from any other state (e.g., from 'On Hold' or 'Assigned').

Full explanation →
443
MCQmedium

A ServiceNow instance has a business rule named 'Update CI Status' that runs on the 'Change Request' table after insert. The rule is intended to update the 'Configuration Item' record's 'Operational Status' to 'Under Maintenance' when a change request is created. The business rule uses the following script: (function executeRule(current, previous != null)) { var gr = new GlideRecord('cmdb_ci'); gr.get(current.cmdb_ci); gr.operational_status = 'Under Maintenance'; gr.update(); })(current, previous); After a recent upgrade to the Vancouver release, the business rule stopped working. The change request is created successfully, but the CI's operational status remains unchanged. The system logs show no errors. What is the most likely cause and the correct fix? A. The business rule is running asynchronously; change it to synchronous. B. The condition field is empty; add 'gs.action() === 'insert'' as the condition. C. The 'current.cmdb_ci' field is not populated; check that the field is required on the form. D. The script uses 'previous' incorrectly; remove 'previous != null' from the function signature.

A.The condition field is empty; add 'gs.action() === 'insert'' as the condition.
B.The business rule is running asynchronously; change it to synchronous.
C.The 'current.cmdb_ci' field is not populated; check that the field is required on the form.
D.The script uses 'previous' incorrectly; remove 'previous != null' from the function signature.
AnswerD

The script uses an invalid function signature with `previous != null`. Removing `!= null` corrects the syntax, allowing the script to run and update the CI.

Why this answer

The business rule contains a syntax error in the function signature. The correct format for a business rule script is `(function executeRule(current, previous))`. The script uses `(function executeRule(current, previous != null))` which is invalid JavaScript and prevents the script from executing.

Since the script never runs, no error appears in the logs, and the CI is not updated. Option A is incorrect because changing to synchronous does not fix a syntax error. Option B is incorrect because the condition field being empty means the rule runs, but the script still fails to execute.

Option C addresses a possible data issue, but the primary cause is the syntax error; even if `cmdb_ci` is populated, the script would still not run.

Full explanation →
444
MCQmedium

A developer wants to create a new UI action that appears on the form only when the record is in a specific state. Which property should be configured?

A.Script condition
B.Condition field
C.Form context menu
D.Insert field
AnswerA

This allows a script to check the current state and return true/false.

Why this answer

The 'Script condition' property allows writing a script to determine visibility based on the record's state, such as checking if the state field equals a particular value. Option B, the 'Condition field', is used for simple condition comparisons but cannot evaluate state without additional scripting. Options C and D are unrelated to visibility logic.

Full explanation →
445
MCQmedium

A company is expanding its use of ServiceNow and needs to create a custom application for managing employee onboarding tasks. The application includes several tables: Onboarding Request, Task, and Checklist Items. The business requires that when an onboarding request is submitted, a set of tasks should be automatically created in a specific order. Additionally, when all tasks are completed, the onboarding request status should automatically update to 'Completed'. The developer decides to use Flow Designer to automate this process. The developer creates a flow with a trigger on the Onboarding Request table for 'Record created or updated' and adds actions to create tasks. However, during testing, the flow creates tasks but does not update the request status when tasks are completed. What is the most likely issue?

A.The flow is set to run only on create, not on update.
B.The flow uses a 'Wait for condition' action that is not configured correctly.
C.The user does not have rights to update the Onboarding Request table.
D.The flow is not configured to listen for updates on the Task table.
AnswerD

Correct: The flow needs a trigger on Task table to respond to task completion.

Why this answer

The flow is triggered only by events on the Onboarding Request table. To update the request status when tasks are completed, the flow must also listen for updates on the Task table (e.g., via a separate flow or a 'Wait for condition' that polls the Task table). Without a trigger or condition monitoring the Task table, the flow has no way to know when tasks finish.

Exam trap

ServiceNow often tests the misconception that a single flow triggered on one table can automatically react to changes in a related table without an explicit trigger or condition on that related table.

How to eliminate wrong answers

Option A is wrong because the trigger is set for 'Record created or updated', so it runs on both create and update events on the Onboarding Request table. Option B is wrong because a 'Wait for condition' action could be used to poll the Task table, but the core issue is that the flow lacks any trigger or mechanism to react to Task table updates; the problem is not misconfiguration of a wait action but the absence of a trigger on the Task table. Option C is wrong because if the user lacked rights to update the Onboarding Request table, the flow would fail entirely or produce an error, not silently skip the status update.

Full explanation →
446
MCQmedium

A company uses a business rule to set a field on the Incident table based on the caller's department. However, the rule runs correctly on insert but not on update. The developer suspects the condition is incorrect. The current script uses: if (current.operation() == 'insert' && gs.getUser().getDepartment() == 'IT'). What might be the issue?

A.The condition should check current.caller_id.department instead
B.The rule is set to run only on insert
C.The script uses synchronous business rule instead of asynchronous
D.The condition should use current.operation() == 'update' as well
AnswerA

The script should use current.caller_id.department to reference the caller's department.

Why this answer

The business rule should check the department of the caller associated with the incident record, not the logged-in user. The condition `current.caller_id.department` retrieves the department value from the caller's user record via a dot-walk to the sys_user table, ensuring the rule triggers based on the incident's caller, not the session user. The current script incorrectly uses `gs.getUser().getDepartment()`, which returns the department of the user running the update, which may differ from the caller's department, causing the rule to fail on update.

Exam trap

The trap here is that candidates often confuse the session user (`gs.getUser()`) with the record's related user (e.g., caller_id), leading them to overlook the need to dot-walk to the caller's department instead of using the logged-in user's department.

How to eliminate wrong answers

Option B is wrong because the rule's 'When to run' configuration is not mentioned in the question; the developer suspects the condition is incorrect, not the trigger timing, and the script already checks `current.operation() == 'insert'`, so the rule could still run on update if the condition were fixed. Option C is wrong because synchronous vs asynchronous execution affects when the rule runs relative to the database operation, not the condition logic; the issue is the condition's field reference, not the execution mode. Option D is wrong because adding `current.operation() == 'update'` would still not fix the core problem—the condition would still check the wrong department (the session user's department) instead of the caller's department, and the rule would still fail to set the field correctly on update.

Full explanation →
447
MCQmedium

An admin notices that a business rule on the 'incident' table that sets the 'assigned_to' field based on the caller's manager is not always firing. The rule is set to run 'Before' and 'Update'. What is the most likely reason?

A.The condition of the business rule is not met because it requires a specific field to change.
B.The business rule is set to run asynchronously.
C.The user lacks the 'incident_edit' ACL.
D.The business rule order is set to 100, making it run too late.
AnswerA

Correct: The rule may check a condition that is not satisfied.

Why this answer

Business rules with conditions only fire when the condition is met. If the condition requires a specific field to change (e.g., 'assigned_to' or a related field), but the update does not include that field, the rule will not trigger. Option B is incorrect: asynchronous execution would still cause the rule to run, just not immediately.

Option C is incorrect: ACLs control access to records, not business rule execution. Option D is incorrect: order 100 is the default and does not prevent firing; it only affects execution order among multiple rules.

Full explanation →
448
Multi-Selecthard

Which TWO conditions must be met for a Scoped Application to access a table from another scope without using an access grant?

Select 2 answers
A.The application is installed in the same instance as the table
B.The table is extended from a table in the consumer application scope
C.The table name starts with 'sys_'
D.The table belongs to the global scope
E.The table is marked as 'Allow access to all application scopes' in its application file
AnswersD, E

True; global tables are accessible by all scoped applications by default.

Why this answer

Tables in the global scope are accessible by default to all scoped applications without requiring an explicit access grant. This is a fundamental rule in ServiceNow's scoping model: global-scope tables are considered shared resources, so any scoped application can read from or write to them as long as the application is installed in the same instance. Option E is also correct because marking a table as 'Allow access to all application scopes' in its application file explicitly overrides the default scope isolation, granting cross-scope access without a grant.

Exam trap

ServiceNow often tests the misconception that any table in the global scope is automatically accessible, but the trap here is that candidates confuse 'global scope' with 'system tables' (sys_ prefix) or assume that extension implies access, leading them to pick options B or C instead of recognizing the explicit conditions required for grant-free access.

Full explanation →
449
Multi-Selecthard

A developer is writing a business rule that should trigger on update of the 'short_description' field of an incident. The rule needs to check if the new value contains 'urgent' and, if so, set the priority to 1. Which TWO statements are true about implementing this rule?

Select 2 answers
A.The condition 'current.short_description.changes()' can be used to ensure the rule runs only when short_description changes.
B.The new value of short_description can be accessed using current.short_description.
C.The new value of short_description can be accessed using previous.short_description.
D.To set the priority, use current.priority.setValue(1).
E.The comparison should use current.short_description.indexOf('urgent') !== -1.
AnswersA, B

Correct. The changes() method on a GlideElement returns true only when the field's value has been modified during the current transaction.

Why this answer

The changes() method on a GlideElement returns true only when the field's value has been modified during the current transaction. Placing `current.short_description.changes()` in the business rule's condition ensures the rule triggers only when the short_description field is updated, not on other field changes. Option B is correct because `current` always holds the updated record after the database write; thus `current.short_description` contains the new value.

Options C and D are incorrect: `previous.short_description` holds the old value before the update, and `setValue()` is not a method on GlideRecord fields—priority should be set by direct assignment (e.g., `current.priority = 1`). Option E is incorrect because `current.short_description` is a GlideElement object, not a plain string; the indexOf() method does not exist on GlideElement. To check for a substring, you must convert to string first, e.g., `current.short_description.toString().indexOf('urgent') !== -1`.

Therefore, the two true statements are A and B.

Exam trap

The trap here is that candidates often confuse `current` and `previous`—thinking `previous` holds the new value—or mistakenly use `setValue()` instead of direct assignment for GlideRecord fields.

Full explanation →
450
MCQmedium

A developer is creating a REST API in ServiceNow to expose incident data. The API must return only incidents with 'state' = 2 (in progress) and limit results to 50. Which implementation is correct?

A.Use the ServiceNow table API with endpoint '/api/now/table/incident?state=2&sysparm_limit=50'.
B.In the script, use 'gr.addQuery('state', 2); gr.setLimit(50);' and return the records.
C.Use a REST API endpoint with path /api/incidents and set the query parameter 'sysparm_query=state=2' and 'sysparm_limit=50'.
D.In the script, use 'gr.get('state', 2)' and then limit via 'gr.setLimit(50)'.
AnswerB

This is the standard approach in a scripted REST API handler.

Why this answer

It uses the standard GlideRecord pattern to query the incident table with an 'addQuery' filter for state=2 and 'setLimit' to restrict results to 50, which is the proper server-side approach when building a custom REST API endpoint in a Scripted REST API or similar. The other options misuse table API syntax or GlideRecord methods in ways that would not work as intended.

Exam trap

The trap here is confusing the built-in table API's parameter syntax (which requires 'sysparm_query' for filters) with the GlideRecord method syntax, and assuming that 'gr.get()' can be used to filter multiple records when it is designed for single-record retrieval by key.

How to eliminate wrong answers

Option A is wrong because the ServiceNow table API endpoint '/api/now/table/incident' does not accept a raw query parameter like 'state=2'; it requires the 'sysparm_query' parameter with an encoded query string (e.g., 'sysparm_query=state=2'). Option C is wrong because the path '/api/incidents' is not a valid ServiceNow REST API endpoint; the correct base path for table APIs is '/api/now/table/', and query parameters must be 'sysparm_query' and 'sysparm_limit', not 'sysparm_query=state=2' without proper encoding. Option D is wrong because 'gr.get('state', 2)' is used to retrieve a single record by sys_id or a unique key, not to filter a set of records; it would return only one record (if any) and ignore the limit.

Full explanation →
Page 5

Page 6 of 7

Page 7

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 →