ServiceNow CAD Certified Application Developer - ServiceNow Exam Practice Test

In ServiceNow, extending a table means creating a new table (child class) that inherits properties from an existing table (parent class). This inheritance includes fields, business logic, and other configurations, allowing for efficient reuse and customization.

Key Points:

Field Inheritance: The child table inherits all fields from the parent table. For example, if you extend the Task table, your new table will include fields like "short_description" and "priority."

Business Logic Inheritance: The child table also inherits business rules, client scripts, and other logic defined on the parent table, ensuring consistent behavior across related tables.

Access Controls: Access controls are not ignored; instead, the child table inherits the parent table's access controls. However, you can define additional access controls specific to the child table as needed.

Customization: While the child table inherits many properties, you can add new fields, scripts, and behaviors to tailor it to specific requirements without affecting the parent table.

In ServiceNow, a workflow context refers to a specific instance of a workflow execution. When a workflow is initiated—whether by inserting or updating a record, triggering an event, or through scripts—the system creates a workflow context. This context is derived from a particular version of the workflow and is responsible for executing the defined activities and following the specified transitions within that workflow.

Key points about workflow context:

Instance of Execution: Each time a workflow runs, a new context is created to manage that specific execution instance. This allows multiple instances of the same workflow to operate independently and simultaneously.

Execution of Activities: The context manages the progression through the workflow's activities, ensuring that each step is executed in the defined order and under the specified conditions.

Tracking and Management: Workflow contexts enable administrators to monitor the state and progress of workflow executions. They provide visibility into which activities have been completed, which are pending, and any transitions that have occurred.

For example, if a workflow is designed to handle approval processes, each time an approval is initiated, a new workflow context is created to manage that particular approval instance. This context will track the approval's progress, manage notifications, and handle any branching logic defined in the workflow.

A Record Producer is a type of service catalog item that allows users to create records on a specified table. A Record Producer has the following characteristics:

Graphics can be included on the user interface: You can add images, icons, or banners to the Record Producer to make it more appealing and informative for the user. You can also use HTML and CSS to customize the layout and style of the Record Producer.

You can script behaviors of fields in the user interface: You can use Client Scripts and UI Policies to control the behavior and appearance of the fields on the Record Producer. For example, you can use Client Scripts to validate the field inputs, perform calculations, or populate default values. You can also use UI Policies to show or hide fields, make fields mandatory or read-only, or set field values based on conditions.

Each field prompts the user with a question rather than a field label: You can use the Variable Question field to define the question that prompts the user for the field value. The question can be more descriptive and user-friendly than the field label. For example, you can use the question “What is the name of the project?” instead of the field label “Name”.

The other statements are not true for Record Producers. Record Producers do not always insert records into the Requested Item [sc_req_item] table. They can insert records into any table that is specified in the Record Producer properties. Record Producers also do not have to be scripted. They can use the default script that maps the variable values to the record fields, or they can use a custom script that defines the logic for creating the record.

References:

[Record Producers]

[Record Producer properties]

[Record Producer scripts]

Business Rule is server-side, so it uses GlideSystem API. gs.hasRoleExactly doesn't exist

In a Business Rule, the following returns true if the currently logged in user has the admin role:

gs.hasRole(‘admin’). This is the correct answer because gs is the GlideSystem object, which provides methods for performing system operations, and hasRole is a method that checks if the current user has the specified role. For example, gs.hasRole(‘admin’) will return true if the current user has the admin role, and false otherwise.

The following do not return true if the currently logged in user has the admin role in a Business Rule:

g_form.hasRoleExactly(‘admin’). This is not correct because g_form is the GlideForm object, which provides methods for manipulating forms, and hasRoleExactly is a method that checks if the current user has exactly the specified role and no other roles. For example, g_form.hasRoleExactly(‘admin’) will return true if the current user has only the admin role, and false if the current user has the admin role and any other role.

g_form.hasRole(‘admin’). This is not correct because g_form is the GlideForm object, which provides methods for manipulating forms, and hasRole is a method that checks if the current user has the specified role or any role that contains the specified role. For example, g_form.hasRole(‘admin’) will return true if the current user has the admin role or any role that contains the admin role, such as admin_ui or admin_script.

gs.hasRoleExactly(‘admin’). This is not correct because gs is the GlideSystem object, which provides methods for performing system operations, and hasRoleExactly is not a valid method of the gs object. There is no method that checks if the current user has exactly the specified role and no other roles in the gs object. References: Business Rules, GlideSystem, GlideForm

To receive email notifications, a user must have an active account and a valid email address in the user record. If either of these conditions is not met, the user will not be able to receive any email notifications from the system.

References:

Create an email notification

Example scripting for email notifications

https://developer.servicenow.com/dev.do#!/learn/courses/sandiego/app_store_learnv2_learnmore_sandiego_learn_more/app_store_learnv2_learnmore_sandiego_form_and_list_layouts/app_store_learnv2_learnmore_sandiego_what_is_form_designer

The Form Designer is a tool that allows you to create and customize forms on the ServiceNow platform. The Form Designer has four main components:

Form layout: The form layout shows the preview of the form and allows you to drag and drop fields, sections, and related lists onto the form. You can also resize, reorder, and delete the elements on the form layout.

Page header: The page header shows the name of the table and the form that you are editing. You can also access the form properties, save the form, and switch to the form view from the page header.

Field navigator: The field navigator shows the list of available fields for the table and allows you to search, filter, and add fields to the form. You can also create new fields and edit existing fields from the field navigator.

Schema map: The schema map is not part of the Form Designer. The schema map is a separate tool that shows the relationships between tables and fields on the platform. You can access the schema map from the System Definition > Tables module or from the context menu of a table.

References:

[Form Designer]

[Schema map]

"You must first select read access to grant any other API record operation." https://docs.servicenow.com/bundle/tokyo-application-development/page/build/applications/reference/r_TableApplicationAccessFields.html

The Application Access configuration fields control the access level for an application and its tables. The following Application Access configuration fields are not available if the Can read configuration field is not selected:

Can create. This field determines whether users can create records on the application tables.

Can update. This field determines whether users can update records on the application tables.

Can delete. This field determines whether users can delete records on the application tables.

These fields are not available because they depend on the Can read field, which determines whether users can view records on the application tables. If users cannot read records, they cannot create, update, or delete them either.

The following Application Access configuration fields are available regardless of the Can read configuration field:

All access to this table via web services. This field determines whether users can access the application tables using web services, such as REST or SOAP.

Allow configuration. This field determines whether users can configure the application tables, such as adding or modifying fields, views, or indexes. References: Application Access, Certified Application Developer (CAD) Learning Path

ServiceNow supports publishing an application to an application repository, an Update Set, or the ServiceNow Store. These methods allow the application to be installed on other instances or shared with other users.

References:

Publish an application to the application repository

4 Ways to Publish a ServiceNow Application

Publish applications to the ServiceNow Store

Application Access is a feature that allows you to control the access level of other application scopes to your application’s data tables. By selecting the Allow access to this table via web services option, you can enable other application scopes to access your data tables using web services, such as SOAP or REST. However, the user performing the query via web services must have the correct permissions to access the table’s records. The user must have the appropriate roles and access controls to perform the operations on the table, such as create, read, write, or delete.

The other statements are not true when this option is selected. This option does not restrict the ability to delete records via web services, nor does it allow records to be always read. The access to the records depends on the user’s permissions and the web service method. This option also does not restrict access only to SOAP web services, but applies to both SOAP and REST web services. Finally, this option is not the only way to enable web service access to the table’s records. Even when this option is not selected, users with the correct permissions can use web services to access the table’s records, as long as they specify the application scope in the web service request.

References:

Application Access

Web service access to scoped applications

Flow Designer is a graphical tool that allows users to automate processes in ServiceNow without coding. The following are supported by Flow Designer:

Call a subflow from a flow. This is a feature that allows users to invoke a subflow, which is a reusable unit of logic, from a flow. This can help simplify complex flows and avoid duplication of logic.

Use Delegated Developer. This is a feature that allows administrators to delegate the development and maintenance of flows and actions to users who are not administrators. This can help distribute the workload and empower non-admin users to create automations.

Run a flow from a MetricBase Trigger. This is a feature that allows users to trigger a flow based on a MetricBase query, which is a way of analyzing time-series data in ServiceNow. This can help automate actions based on data trends and patterns.

The following is not supported by Flow Designer:

Test a flow with rollback. This is not a feature of Flow Designer, but of Automated Test Framework (ATF), which is a tool that allows users to create and run automated tests on ServiceNow applications and features. ATF supports testing flows with rollback, which means reverting any changes made by the flow during the test execution. References: Flow Designer, Automated Test Framework

"The sequence is ROLES first, then condition, then script." - Chuck Tomasi says so at this link: https://www.servicenow.com/community/grc-forum/order-of-execution-of-an-acl/m-p/1311962/highlight/true#M6538

https://docs.servicenow.com/bundle/tokyo-application-development/page/script/server-scripting/concept/c_ServerScripting.html

The Automated Test Framework (ATF) is a tool that allows you to create and run automated tests on the ServiceNow platform. The ATF uses test steps to define the actions and validations for each test. The test step that allows you to create a user with specified roles and groups for the test is the Create a user test step. This test step creates a temporary user record that is deleted at the end of the test. You can specify the user name, password, roles, and groups for the user. You can also use the Impersonate a user test step to switch to the created user and perform actions as that user.

The other options are not valid test steps for creating a user. The Create a role and Create a group test steps do not exist in the ATF. To create a role or a group, you need to use the Create a record test step and specify the sys_user_role or sys_user_group table. The Impersonation test step does not create a user, but switches to an existing user.

References:

[Automated Test Framework overview]

[Automated Test Framework test steps]

[Create a user test step]

[Impersonate a user test step]

Checkbox tooltip: "Show this module when the user has the specified roles. Otherwise the user must have the roles specified by both the application menu and the module."

The following is true for the Override application menu roles configuration option when configuring a module:

Users with the module role but without access to the application menu access the module. This is true because the Override application menu roles option allows users to bypass the application menu role requirement and access the module directly if they have the module role. For example, if a module has the itil role and the Override application menu roles option enabled, and the application menu has the admin role, then a user who has the itil role but not the admin role can still access the module.

The following are not true for the Override application menu roles configuration option when configuring a module:

Self-Service users can access the module even though they do not have roles. This is false because the Override application menu roles option does not grant access to the module to users who do not have any roles. Self-Service users are users who do not have any roles assigned to them and can only access the Self-Service portal and the Knowledge Base. To access the module, users need to have at least the module role.

Admin is given access to the module even if Access Controls would ordinarily prevent access. This is false because the Override application menu roles option does not override the Access Control (ACL) rules that apply to the module. Access Control rules are used to restrict the access to the data and functionality of the ServiceNow platform based on the user’s roles and conditions. Admin is a role

It is possible to change an application’s scope in ServiceNow, either from global to private or from private to global. However, changing the scope of an application may affect its functionality and compatibility with other applications. Therefore, it is recommended to test the application thoroughly before and after changing its scope.

References:

How To Change Application Scope In ServiceNow - YouTube

How to move Custom Scoped Applications bettween instances - ServiceNow

Steps to switch a scoped application from your company’s application repository to update sets - ServiceNow

How to change the application (scope) of a SLA Definition without needing to recreate the SLA Definition - ServiceNow

Advantages of Scoped Applications in ServiceNow - QualityClouds

The Create Branch operation is available from both Studio and the Git Repository. This operation allows you to create a new branch from an existing branch in your Git repository. You can use branches to work on different features or versions of your application without affecting the main branch. Reference: [Create a branch]

https://developer.servicenow.com/dev.do#!/reference/api/paris/server_legacy/c_GlideSystemAPI#r_GS-nowNoTZ

The ServiceNow REST API is a web service that allows you to interact with the ServiceNow platform using HTTP requests and responses. The ServiceNow REST API supports the following methods:

POST: This method allows you to create a new record or execute an action on the ServiceNow platform. For example, you can use the POST method to create an incident or run a script.

GET: This method allows you to retrieve information from the ServiceNow platform. For example, you can use the GET method to get the details of a user or a table.

DELETE: This method allows you to delete a record or a resource from the ServiceNow platform. For example, you can use the DELETE method to delete an attachment or a workflow context.

PUT: This method allows you to update a record or a resource on the ServiceNow platform. For example, you can use the PUT method to update the state of a task or the value of a system property.

PATCH: This method allows you to update a record or a resource on the ServiceNow platform by sending only the changes. For example, you can use the PATCH method to update the short description of an incident or the order of a module.

The method COPY is not part of the ServiceNow REST API. There is no COPY method in the HTTP protocol. To copy a record or a resource on the ServiceNow platform, you need to use the POST method with the clone action.

References:

ServiceNow REST API overview

ServiceNow REST API methods

[ServiceNow REST API actions]

In ServiceNow, the "Allow access to this table via web services" option within the Application Access settings determines whether the table can be accessed through web service protocols, such as REST and SOAP. When this option is selected, it permits the table to be accessible via web services; however, it does not override existing permissions. The user or system making the web service request must still have the appropriate permissions (such as roles and access controls) to perform operations on the table's records.

Option A: Incorrect. If the "Allow access to this table via web services" option is not selected, the table is not accessible via web services, regardless of user permissions.

Option B: Correct. Enabling this option allows the table to be accessed via web services, but the user must have the correct permissions to access the table's records.

Option C: Incorrect. This option applies to all web service protocols, including both SOAP and REST.

Option D: Incorrect. This option controls overall web service access to the table; specific operations (create, read, update, delete) are governed by user permissions and access controls.

The data type of a field determines the format, validation, and display of the field value on a form. When selecting a data type for a field, you should consider the purpose and function of the field. The statements A, C, and D are correct for selecting a data type for a field. For example:

Use the Choice data type to limit options in a field: The Choice data type allows you to create a field that has a predefined set of options for the user to select from. The options can be displayed as a drop-down list, radio buttons, or checkboxes. For example, you can use the Choice data type for a field that indicates the priority of a task.

Use the Phone Number data type to automate phone number data validation: The Phone Number data type allows you to create a field that accepts and validates phone numbers. The field will automatically format the phone number according to the user’s locale and country code. For example, you can use the Phone Number data type for a field that stores the contact number of a user.

Use the string data type for a free-form text field: The string data type allows you to create a field that accepts any text input from the user. The field can have a maximum length of 255 characters. For example, you can use the string data type for a field that captures the short description of an incident.

The statement B is not correct for selecting a data type for a field. There is no Data data type in ServiceNow. To enter the date and time of day, you should use the Date/Time data type. The Date/Time data type allows you to create a field that accepts and displays a date and time value. The field will use a calendar widget and a time picker to help the user enter the value. For example, you can use the Date/Time data type for a field that records the due date of a task.

References:

[Field types]

[Date/Time field type]

https://docs.servicenow.com/bundle/tokyo-application-development/page/build/applications/concept/c_ApplicationPicker.html

In ServiceNow, UI Actions are elements such as buttons, links, and context menu items that allow users to perform actions on records or lists. The three valid UI Action types are:

1. List Banner Button (Option A)

Description: A button that appears in the list view header, allowing users to trigger an action affecting multiple records at once.

Example: A "Bulk Approve" button that processes selected records.

2. Form Button (Option B)

Description: A button that appears on a form, allowing users to trigger actions related to the current record.

Example: A "Submit for Approval" button on an incident form.

3. Record Navigation Button (Option D)

Description: A button that helps users navigate between related records.

Example: A "Go to Parent Record" button that redirects users to a linked record.

Incorrect Options:

Form Choice (Option C):

Not a UI Action type. Choices are typically used in choice fields (dropdowns) rather than UI actions.

List Choice (Option E):

Not a valid UI Action type. Similar to "Form Choice," it pertains to field options rather than UI elements.

Workflow Action (Option F):

Workflows are process automation tools, not UI Actions. They are not directly related to buttons or links that users interact with.

https://docs.servicenow.com/bundle/tokyo-application-development/page/script/server-scripting/concept/c_ServerScripting.html

"By default, all application scope scripts can read the table's records but cannot perform any other database operations." https://developer.servicenow.com/dev.do#!/learn/learning-plans/tokyo/servicenow_administrator/app_store_learnv2_securingapps_tokyo_application_access_database_settings

Comprehensive and Detailed Step-by-Step Explanation:

Options for Creating Tables in Guided Application Creator:

Create a table from scratch: This option allows you to define a completely new table with custom fields and configurations.

Create a table from a template: You can use predefined table templates to speed up table creation. Templates often include pre-configured fields and settings.

Extend a table: This allows you to create a new table by inheriting fields and functionality from an existing table, enabling reuse and consistency.

Why Other Options Are Incorrect:

Option A (Link to external tables): Linking to external tables is not an option provided in the Guided Application Creator; external data is typically accessed through integration methods.

Option D (Run import jobs): Import jobs are used for data migration, not for table creation in the Guided Application Creator.

Option E (Upload a spreadsheet): While uploading a spreadsheet can create tables, this is a feature of Import Sets, not the Guided Application Creator.

Option F (Use API calls): API calls are for integration and not an option for creating tables directly in the Guided Application Creator.

References:

ServiceNow Developer Documentation on Guided Application Creator​.

https://docs.servicenow.com/bundle/tokyo-application-development/page/build/applications/task/t_IncludeApplicationData.html

Comprehensive and Detailed Step-by-Step Explanation:Inherited fields in ServiceNow are fields that are part of a parent table and automatically become part of child tables through inheritance. This structure is foundational in the ServiceNow data model, ensuring that child tables maintain a consistent relationship with their parent tables.

Here’s why inherited fields cannot be deleted from a child table:

System Design:ServiceNow employs a table inheritance model where child tables derive fields and properties from parent tables. Deleting inherited fields from a child table would break the integrity of the data model, as those fields are shared across multiple tables.

Impact on Functionality:Many inherited fields, such as sys_created_on or sys_updated_by, are integral to the functionality of the platform. Removing them could disrupt workflows, reporting, and auditing capabilities.

Alternative Approach:If you want to hide or restrict access to inherited fields in a child table, you can use ACLs (Access Control Lists) to prevent users from viewing or modifying these fields. Another option is to use UI Policies or Client Scripts to control their visibility on forms.

Developer Note:Attempting to delete inherited fields violates ServiceNow’s core principles of maintaining a robust and unified data structure. The platform enforces these rules to ensure consistent behavior across all tables in the hierarchy.

References:

ServiceNow Developer Documentation on Table Inheritance​.

Best practices outlined on SN Pro Tips regarding scoped application development and table structures​.

In ServiceNow, Application Access settings at the table level allow developers to control which operations from other application scopes can be performed on their application's tables. The specific database operations that can be controlled are:

Can read: Allows other application scopes to read records from the table.

Can create: Allows other application scopes to create new records in the table.

Can update: Allows other application scopes to modify existing records in the table.

Can delete: Allows other application scopes to delete records from the table.

Options A (Update) and B (Create) are correct because "Can update" and "Can create" are among the operations that can be controlled through Application Access settings.

Options C (Execute) and D (Query) are incorrect. While "Execute" pertains to the ability to run scripts or script includes, it is not a database operation controlled by Application Access but rather by script access settings. "Query" corresponds to reading data, which is governed by the "Can read" setting.

For more detailed information, refer to the official ServiceNow documentation on Application Access settings:

SERVICENOW.COM

https://docs.servicenow.com/bundle/tokyo-platform-administration/page/administer/platform-events/reference/r_ScriptActions.html

there are only two types of UX options: Mobile and Classic. Classic is defined as "manage records via lists and form"

In ServiceNow, a Record Producer allows users to create records in a specific table through the Service Catalog. After a user submits a Record Producer, developers may want to redirect the user to a specific page. This can be achieved by setting the producer.redirect property within the Script field of the Record Producer.

For example:

javascript

CopyEdit

producer.redirect = 'incident.do?sys_id=' + current.sys_id;

This script redirects the user to the newly created incident record after submission.

Option A is incorrect because configuring the module that opens the Record Producer does not control the post-submission behavior.

Option C is unnecessary for simple redirection purposes; creating an application property to store the URL adds unnecessary complexity.

Option D is incorrect because using window.redirect in a Business Rule is not appropriate; Business Rules run on the server side and do not have access to the client-side

In ServiceNow, Access Controls (ACLs) are used to manage permissions for various database operations on tables and their records. The primary operations that can be controlled include:

Create:

Description: Permission to insert new records into a table.

Control: ACLs can be defined to allow or deny users the ability to create records based on roles, conditions, or scripts.

Update:

Description: Permission to modify existing records in a table.

Control: ACLs can restrict who can update records, ensuring that only authorized users can make changes.

Other Operations:

Read: Controls the ability to view records in a table.

Delete: Manages the permission to remove records from a table.

Incorrect Options:

Execute: Not a standard database operation controlled by ACLs in ServiceNow.

Query: While querying is part of the read operation, ACLs specifically control the read access rather than the query process itself.

https://developer.servicenow.com/dev.do#!/learn/courses/tokyo/app_store_learnv2_scripting_tokyo_scripting_in_servicenow/app_store_learnv2_scripting_tokyo_server_side_scripting/app_store_learnv2_scripting_tokyo_script_includes

Comprehensive and Detailed Step-by-Step Explanation:

UI Action Types:

List banner button: A button that appears in the list view banner, allowing users to perform actions on multiple records or interact with the list itself.

Form button: A button that appears on a form, enabling users to execute server-side or client-side scripts.

Record navigation button: A button used to navigate between records or perform specific actions related to a record.

Why Other Options Are Incorrect:

Option B (Workflow action): This is not a valid UI Action type; workflows are managed separately.

Option D (List choice) and Option E (Form choice): These are not valid UI Action types; they might confuse users with list or form field options instead.

References:

ServiceNow Developer Documentation on UI Actions​.

Comprehensive and Detailed Step-by-Step Explanation:

Record Producer Overview:Record Producers in ServiceNow are a way to create records through a simplified user interface. Instead of displaying a typical form, a Record Producer uses a user-friendly UI tailored for quick and intuitive data entry.

Correct Link Type:

The URL (from Arguments) option is used to direct the user to a specific URL, such as the Record Producer interface. You can configure the URL in the module to point to the Record Producer by providing its unique sys_id or name.Example URL:

/catalog.do?sys_id=

Incorrect Options Explained:

Content Page (Option A): This opens a CMS page and is not used for Record Producers.

Script (from Arguments) (Option B): This runs a custom script but does not link directly to a Record Producer.

HTML (from Arguments) (Option D): This is used for rendering custom HTML, not for linking to a Record Producer.

References:

ServiceNow Developer Documentation on Modules and URL Arguments​.

https://docs.servicenow.com/bundle/tokyo-application-development/page/build/guided-app-creator/concept/guided-app-creator.html

https://docs.servicenow.com/bundle/tokyo-servicenow-platform/page/administer/notification/task/t_CreateANotification.html

https://developer.servicenow.com/dev.do#!/learn/learning-plans/quebec/new_to_servicenow/app_store_learnv2_automatingapps_quebec_when_to_send

The Weight field in an Email Notification determines which notification is sent when multiple notifications are triggered for the same record and recipients. Only the notification with the highest weight is sent. A weight value of zero means the notification is always sent when the notification’s When to send criteria is met. A weight value of -1 means that no email should be sent3. References: Email Notification Weight

"Restricted caller access [sys_restricted_caller_access] records track cross-scope applications or scripts that request access to an application, application resource, or event in the Now Platform." <<== this is the third sentence down in the following link: https://docs.servicenow.com/bundle/tokyo-application-development/page/build/applications/concept/restricted-caller-access-privilege.html

From the list below, the following is a reason an application might not be a good fit with ServiceNow:

Requires “as-is” use of low-level programming libraries. This is the correct answer because ServiceNow is a high-level platform that abstracts away the low-level details of the underlying infrastructure and technology stack. ServiceNow provides a rich set of APIs, tools, and features that allow users to develop applications without coding or with minimal coding. However, ServiceNow does not support the direct

Debugging client-side scripts in ServiceNow involves using methods that provide feedback during script execution. The following methods are commonly used:

g_form.addInfoMessage():

Description: Displays informational messages to the user within the form interface.

Usage: g_form.addInfoMessage('Your message here');

Purpose: Useful for providing real-time feedback or debugging information directly on the form during script execution.

jslog():

Description: Logs messages to the browser's console.

Usage: jslog('Your debug message here');

Purpose: Helps developers output debugging information to the browser console, which can be inspected during development.

Incorrect Options:

gs.addErrorMessage(): This is a server-side method used to display error messages to the user and is not applicable for client-side debugging.

gs.log(): Another server-side method used to log messages to system logs, not suitable for client-side script debugging.

To include specific records from a table (often referred to as seed data) when distributing an application in ServiceNow, developers must add these records to the application as application files. This ensures that when the application is installed on another instance, the specified records are included.

Option C is correct because using the "Create Application Files" feature allows developers to select specific records to include in the application package. This process creates application files for the selected records, ensuring they are installed along with the application on other instances.

Options A, B, and D are incorrect:

A: The activation status of Table A and whether it extends the Task table do not determine whether its records are included during installation.

B: Having an automatic number counter and setting a table property do not control the inclusion of records in the application package.

D: The System Clone > Exclude Tables list pertains to cloning operations and does not affect application installation.

For detailed guidance on including table records in application deployments, refer to the official ServiceNow documentation:

SERVICENOW.COM

An example of when an application might not use a Scheduled Script Execution (Scheduled Job) is when the application needs to run a client-side script at the same time every day. A Scheduled Script Execution is a server-side script that runs on a specified schedule and performs some action on the server or database. A client-side script runs on the user’s browser and cannot be scheduled by ServiceNow. The other options are examples of when an application might use a Scheduled Script Execution, such as sending email reminders, running a clean up script, or querying the database for unassigned records. Reference: Scheduled Script Execution, Client scripts

Comprehensive and Detailed Step-by-Step Explanation:

Understanding Application Scope and Picker:

The Application Picker in ServiceNow allows developers to switch between different applications (scopes).

When you select an application from the Application Picker, the Application Scope is set to that application, enabling you to develop or configure within that scope.

Why Other Options Are Incorrect:

Option A: The Global application does appear in the Application Picker.

Option B: Selecting Global does not set the scope to Incident; it sets the scope to the Global application, which is not restricted by scoped boundaries.

Option D: Selecting an application does indeed set the Application Scope.

References:

ServiceNow Developer Documentation on Application Scope​.

Self-invoking. Learn JavaScript!

This type of JavaScript function is known as self-invoking or immediately-invoked function expression (IIFE). It is a function that is defined and executed at the same time, without being assigned to a variable or being called by another function. It is often used to create a local scope for variables and avoid polluting the global namespace. References: [W3Schools - JavaScript Function Definitions], [MDN Web Docs - Immediately-invoked function expressions]

Global applications can use Automated Test Framework and Flow Designer features, but not Source Control and Delegated Development features. Source Control and Delegated Development features are only available to scoped applications . References: [Global vs Scoped Applications], [Delegated Development]

Search branch and merge branches are available features in Studio. Search branch allows you to search for a specific branch name or ID in your Git repository. Merge branches allows you to merge changes from one branch to another, resolving any conflicts that may arise. Push to external source control and push to update set are not available features in Studio. Push to external source control is a feature of Source Control Integration, which is a separate application from Studio. Push to update set is a feature of Update Set Previewer, which is also a separate application from Studio. Reference: Studio, Source Control Integration, Update Set Previewer

A spoke is a scoped application that contains flow actions that can be used in Flow Designer. Spokes allow developers to create reusable actions that can be shared across applications and instances.

References:

Spokes - Product Documentation: San Diego - ServiceNow

Create a spoke - Product Documentation: San Diego - ServiceNow

Flow Designer Spokes - ServiceNow Developers

https://docs.servicenow.com/bundle/tokyo-application-development/page/build/applications/task/t_SelectAnAppFromTheAppPicker.html

https://developer.servicenow.com/dev.do#!/learn/courses/tokyo/app_store_learnv2_flowdesigner_tokyo_flow_designer/app_store_learnv2_flowdesigner_tokyo_notifications_in_flow_designer/app_store_learnv2_flowdesigner_tokyo_inbound_email_and_flows

"By default, the system generates a watermark label at the bottom of each notification email to allow matching incoming email to existing records." https://docs.servicenow.com/bundle/tokyo-servicenow-platform/page/administer/notification/concept/c_WorkingWithWatermarks.html

The application name is not required to link a ServiceNow application to a Git repository. You only need to provide the URL, user name, and password of the Git repository, as well as the branch name and the authentication type. The application name is automatically generated based on the scope name of your application. Reference: [Link an application to a Git repository]

"There are two possible ways to respond to events:

- Email Notification

- Script Action" - see this quote in link below:

https://developer.servicenow.com/dev.do#!/learn/learning-plans/tokyo/new_to_servicenow/app_store_learnv2_automatingapps_tokyo_responding_to_events

"Guided Application Creator is enabled via the Guided Application Creator (com.glide.sn-guided-app-creator) plugin, which is active by default in the Now Platform." Located under "Activation Information" section at this URL:

https://docs.servicenow.com/en-US/bundle/tokyo-application-development/page/build/guided-app-creator/concept/guided-app-creator.html

In ServiceNow, the Application Picker is a user interface element that allows developers to select the active application they are working on. The selected application determines the Application Scope, which defines the boundaries within which application artifacts (like tables, scripts, and UI components) reside and operate.

A. Selecting Global in the Application Picker sets the Application Scope to Incident: This is incorrect. Selecting "Global" sets the scope to the global application, not specifically to the Incident application.

B. Global is a reserved application that does not appear in the Application Picker: This is incorrect. The "Global" application is available in the Application Picker and represents the global scope.

C. Selecting an application from the Application Picker sets the Application Scope: This is correct. Choosing an application from the Application Picker establishes that application's scope as the current context for development and configuration.

D. Selecting an application from the Application Picker does not set the Application Scope: This is incorrect. The Application Picker directly influences the current Application Scope.

For more information, refer to the official ServiceNow documentation on Application Scope.

For a visual demonstration of restricting access to your ServiceNow application, you may find the following video helpful:

Restricting Access to your ServiceNow App

When designing and creating a form, you can create sections to organize fields on a form. Sections are containers that group related fields together and provide a label and a description for the group. You can use sections to improve the readability and usability of the form. You can also collapse or expand sections to show or hide the fields within them.

The other options are not valid ways to organize fields on a form. Related lists are not fields, but lists of records that are related to the current record on the form. Tabs are not part of the form, but part of the application menu that allows you to navigate between different modules. Buttons are not fields, but elements that perform actions on the form, such as saving, updating, or deleting the record.

References:

[Form sections]

[Related lists]

[Application menus and modules]

[Form buttons]

Access Controls are rules that define who can access what data and how they can access it. When configuring an Access Control, you can specify the table, operation, and role for the rule. You can also add a condition or a script to further refine the rule. If you do not add a condition or a script, the rule will apply to all records and fields on the table.

The statements A, B, and C are true for Access Controls that have no condition or script. For example:

table.* will grant access to every field in a record. This means that the user can view and edit all the fields on the record, regardless of their role or any other criteria.

table.None will grant access to every record on the table. This means that the user can view and edit all the records on the table, regardless of their role or any other criteria.

table.field will grant access to a specific field in a record. This means that the user can view and edit only that field on the record, regardless of their role or any other criteria.

The statement D is not true for Access Controls that have no condition or script. table.id will not grant access to a specific record on the table. This is because the id is not a field name, but a unique identifier for the record. To grant access to a specific record on the table, you need to add a condition or a script that matches the id of the record.

References:

[Access Control rules]

[Create an Access Control rule]