CAD Certified Application Developer - ServiceNow Questions and Answers

In ServiceNow, UI Actions are elements that make the user interface more interactive and tailored to user activities. They can appear as buttons, links, or context menu items on forms and lists. The valid types of UI Actions include:

C. Form choice: These are UI Actions that appear as choices in form context menus, allowing users to perform specific actions related to the form.

D. Form button: These are buttons that appear on forms, enabling users to execute defined actions directly from the form view.

E. List banner button: These are buttons that appear in the list view ' s banner, providing actions that can be performed on the list or selected records.

The other options are not standard UI Action types:

A. Workflow action: While workflows can include actions, " Workflow action " is not a defined UI Action type in ServiceNow.

B. Record navigation button: This is not a standard term used for UI Action types in ServiceNow.

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

The correct statement regarding Application Scope is that applications downloaded from 3rd party ServiceNow application developers cannot have naming conflicts. Application Scope is a feature that identifies and isolates applications and their related artifacts from other applications. Each scoped application has a unique namespace identifier that consists of a prefix and a scope name. This prevents cross-application name collisions and ensures that only authorized scripts can access or modify data in a scoped application. References: [Product Documentation | ServiceNow], [How To Create a Scoped App in ServiceNow - YouTube]

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.

Scheduled Script Executions (formerly known as Scheduled Jobs) are used to run server-side logic at specific intervals, such as querying or updating records automatically. Option B describes a valid server-side scheduled use case.

From ServiceNow Docs (https://developer.servicenow.com/):

“Scheduled Script Executions allow you to define JavaScript logic that runs on a schedule to automate tasks such as checking data integrity, generating reports, or reassigning records.”

Client-side logic like in options A, C, and D must use Client Scripts or UI Policies, not Scheduled Jobs.

The Allow configuration Application Access option determines whether users can configure the application tables, such as adding or modifying fields, views, or indexes. The following is true for a table with the Allow configuration option selected:

Out of scope applications can create Business Rules for the table. This is true because the Allow configuration option grants access to the table configuration to any user who has the admin or personalize_dictionary role, regardless of the application scope. This means that users can create Business Rules, which are server-side scripts that run when a record is displayed, inserted, updated, or deleted, for the table from any application.

The following are not true for a table with the Allow configuration option selected:

Only the in scope application’s scripts can create Business Rules for the table. This is false because the Allow configuration option does not restrict the creation of Business Rules to the in scope application, as explained above.

Any user with the application’s user role can modify the application’s scripts. This is false because the Allow configuration option does not grant access to the application scripts, such as client scripts or script includes, to any user who has the application’s user role. To modify the application scripts, users need to have the admin role or the application’s admin role.

Out of scope applications can add new tables to the scoped application. This is false because the Allow configuration option does not allow out of scope applications to add new tables to the scoped application. To add new tables to a scoped application, users need to have the admin role or the application’s admin role and be in the application scope. References: Application Access, Business Rules

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]

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.

ServiceNow Developer Documentation on Guided Application Creator​.

A benefit of creating an Application Properties page for each application you develop is that Application Properties allow a developer or admin to make changes to an application’s behavior without modifying application artifacts. Application Properties are system properties that store configuration information for a specific application. They can be used to control various aspects of the application, such as feature flags, default values, thresholds, or URLs. By creating an Application Properties page, you can group and display all the properties related to your application in one place and make them easy to access and update. This way, you can avoid hard-coding static data in your application code and make your application more flexible and maintainable. Reference: Working with System Properties, Organizing your ServiceNow System Properties

https://docs.servicenow.com/bundle/tokyo-platform-security/page/administer/contextual-security/concept/access-control-rules.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

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

An Access Control list (ACL) defines what data users can access and how they can access it in ServiceNow tables1. The ACL evaluates the user roles and the conditions defined in the ACL rules to determine the user’s access level2. In this case, the ACL rules for the table are as follows:

table.None read Access Control for users with the admin and itil roles: This means that users with the admin or itil roles cannot read any field in the table unless there is a more specific rule that grants them access3.

table. * read Access Control for users with the admin role: This means that users with the admin role can read all fields in the table.

table. field3 read Access Control for users with the itil role: This means that users with the itil role can read only the field3 in the table.

Therefore, a user with the itil role can read only the field3 in the table, and not the other fields.

References = 1: Access Control Lists - ServiceNow Docs 2: How ACL Rules Are Evaluated - ServiceNow Docs 3: Access Control List Rules - ServiceNow Docs : Wildcard in ACL Rules - ServiceNow Docs : Field-Level ACL Rules - ServiceNow Docs

The Bar Chart and Pie Chart report types can be created by right-clicking on a column header in a table’s list. These report types show how individual pieces of data relate to the whole using proportional bars or slices. You can also choose different aggregation methods such as count, sum, average, min, max, or percent. Reference: [Create reports from lists]

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.

ServiceNow Developer Documentation on Table Inheritance​.

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

The step that does not belong when creating a Utils Script Include is identifying the table. A Script Include is a server-side script that can contain one or more classes or functions that can be reused by other scripts. It does not depend on a specific table, but can access any table through GlideRecord or other APIs. The other steps are part of creating a Script Include class and its prototype object. References: [ServiceNow Docs - Script Includes], [ServiceNow Docs - GlideRecord API]

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

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

The baseline behavior of a table in a privately-scoped application is that all application scopes can read from the table. A privately-scoped application is an application that restricts write access to its tables and resources to scripts within the same scope. However, read access is allowed by default for all scopes, unless the administrator explicitly denies it using an Access Control rule. This allows for data sharing between different applications while maintaining data integrity and security. References: [Product Documentation | ServiceNow], [Advantages of Scoped Applications in ServiceNow]

In the Automated Test Framework (ATF) of ServiceNow, the " Impersonate " test step is used to simulate actions as a specific user. This is crucial for testing functionalities that depend on user roles, permissions, or specific user contexts.

Key Points:

Purpose: The " Impersonate " step allows the test to execute subsequent steps as if performed by the specified user, ensuring that role-based permissions and access controls are accurately tested.

Usage: To add an " Impersonate " step:

Open your test in ATF.

Click on " Add Test Step. "

Select " Impersonate User. "

Choose the user you want to impersonate for the test.

Considerations: Ensure that the user being impersonated has the necessary roles and permissions for the actions being tested. Additionally, be aware that impersonation affects both server-side and client-side operations during the test.

The Protection Policy field on a Script Include controls whether installed application code can be viewed or edited after distribution. “Protected” is intended to protect intellectual property by preventing customers who install or download the application from seeing the Script field content in plain text. It is not activated merely because an admin enables a field, because a user has protected_edit, or because a general system property is set. In CAD terms, this feature matters when distributing custom application code, especially Store-delivered applications, where the developer wants to hide implementation details from consuming instances. Therefore, option A is the correct exam-aligned answer.

================

https://docs.servicenow.com/bundle/rome-platform-administration/page/administer/reference-pages/task/schedule-report.html Generate and distribute scheduled reports via email.

A report is a graphical representation of data from one or more tables in ServiceNow. The following are true for reports in ServiceNow:

Can be a graphical representation of data. This is true because reports can use various chart types, such as pie, bar, line, or gauge, to visualize data in a meaningful way.

Can be run on demand by authorized users. This is true because reports can be accessed from the Reports menu or the Report Navigator and run by users who have the appropriate roles and permissions to view the data.

Can be scheduled to be run and distributed by email. This is true because reports can be configured to run at a specific time and frequency and send the results to one or more email recipients.

The following are not true for reports in ServiceNow:

Any user can see any report shared with them. This is false because users can only see reports that are shared with them if they also have access to the data source of the report. For example, a user who does not have the itil role cannot see a report based on the incident table, even if the report is shared with them.

All users can generate reports on any table. This is false because users can only generate reports on tables that they have access to and that are enabled for reporting. For example, a user who does not have the admin role cannot generate reports on the sys_user table, which is the table for user records. References: Reports, Report Security

The Field Watcher is a debugging tool that allows you to monitor the values of fields on a form as they change due to scripts or other actions. It can be used to debug Business Rules, Client Scripts, and Access Controls, but not Script Includes. Script Includes are server-side scripts that define reusable functions and classes. They are not associated with any specific field or form, and therefore cannot be watched by the Field Watcher.

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

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]

" If there are no spreadsheets or existing tables to use for your application, you can create and customize a new table. " see this quote in link below:

https://docs.servicenow.com/bundle/tokyo-application-development/page/build/app-engine-studio/task/create-table.html

Also see:

https://docs.servicenow.com/bundle/tokyo-application-development/page/build/guided-app-creator/task/gac-create-table-from-scratch.html

Also, no search results if search on " Now Experience Table Creator " .

The welcome screen appears every time a new application is created through the Guided Application Creator. The welcome screen provides an overview of the steps involved in creating an application, such as defining the app name, scope, and tables, configuring the app user interface, and publishing the app. The other options are not true about the Guided Application Creator. The global scope option is turned off by default, as it is recommended to create applications in their own scope for better security and performance. A scope application user role is not automatically created, as the user can choose to create one or use an existing role for the app access control. Default access controls are not automatically created, as the user can define the read, write, create, and delete permissions for each table in the app. Reference: Guided App Creator

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

g_scratchpad is a server-to-client data transfer object used primarily in the classic web UI rendering pipeline. A common, documented pattern is to populate g_scratchpad in a Display Business Rule (server-side) and then read those values in client-side scripts (such as Client Scripts or UI Scripts) while the form is being rendered in the browser. This avoids extra server calls when you need a small set of precomputed values or flags, such as whether the current user meets a condition, whether a related record exists, or which UI behavior should be enabled. It is not used to “populate properties for a Display Business Rule” as an end in itself; rather, the Display Business Rule is the place where developers often set g_scratchpad. It is also not a concept for defining constructors/destructors for table classes. While similar patterns can exist across experiences, g_scratchpad is specifically recognized as a web client bridging mechanism tied to server-side display processing, which matches option B.

https://docs.servicenow.com/bundle/tokyo-application-development/page/app-store/dev_portal/API_reference/GlideQuery/concept/GlideQueryGlobalAPI.html#GlideQueryAPI

https://docs.servicenow.com/bundle/tokyo-application-development/page/app-store/dev_portal/API_reference/glideRecordScoped/concept/c_GlideRecordScopedAPI.html

Client-side scripts run in the user’s browser and are intended to improve or control the form experience. They can hide or show fields, make fields mandatory or read-only, set field values, modify choice list options, and display field or form messages. They should not be used as a true security control because users may bypass client behavior, and they do not directly secure database or backend access. Playbook access and user access are controlled through platform security, roles, ACLs, and application configuration, not ordinary client scripts. In CAD terms, client scripts are primarily for form behavior and user experience. Therefore, B is correct.

ServiceNow ACLs (Access Control Lists) determine whether a user can perform an operation (read, write, create, delete, etc.) on a table, record, or field. When an ACL includes multiple types of checks, the platform evaluates them in a defined sequence. ServiceNow documentation describes permission evaluation using rule types and indicates that Role checks are evaluated first, followed by additional rule criteria such as conditions, and finally scripts when present. This order matters for both security and performance. Role evaluation is typically fastest and can short-circuit further checks. If the user does not meet the role requirement, the platform does not need to evaluate the condition or run a script. Conditions are then evaluated to confirm record-based or context-based requirements. If the ACL still requires deeper logic beyond roles and conditions, a script can be executed last to decide access (often setting an answer value or returning true/false depending on the ACL type). Therefore, among the provided choices, the correct sequence is Roles → Conditions → Script.

Created UI policy on incident form, action set ' s cmdb_ci field as mandatory and script as not. result, field was not mandatory.

A UI Policy’s Actions execute before the UI Policy’s Scripts. Actions are predefined operations that can be applied to fields or sections, such as making them mandatory, read-only, visible, or setting a default value. Scripts are custom JavaScript code that can be used to perform more complex logic or validations. Actions are executed first, and then Scripts are executed if the UI Policy conditions are met. References: [ServiceNow Docs - UI policy actions], [ServiceNow Docs - UI policy scripts]

A Record Producer in ServiceNow is a specific type of catalog item that enables users to create records in a particular table through a simplified interface. They are often used to allow users to create task-based records, such as incidents or change requests, from the Service Catalog.

servicenow.com

Key characteristics of Record Producers include:

Graphics can be included on the user interface: Developers can enhance the user experience by adding images or icons to the Record Producer form, making it more intuitive and visually appealing.

Each field prompts the user with a question rather than a field label: Instead of standard field labels, Record Producers can present fields as questions to guide users in providing the necessary information. This approach makes the form more user-friendly and context-specific.

You can script behaviors of fields in the user interface: Developers have the flexibility to add client-side scripts to control the behavior of fields on the Record Producer form. This capability allows for dynamic interactions, such as showing or hiding fields based on user input or pre-populating fields with specific data.

Option A is incorrect because records created by a Record Producer are inserted into the table specified during its configuration, not necessarily the Requested Item [sc_req_item] table. Option C is incorrect because scripting is not mandatory for Record Producers; they can function without additional scripting, although scripting can be used to enhance functionality when needed.

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.

" 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

A Read-only protection policy allows the Script Include logic to be visible but prevents changes to the script on the instance where the application is installed. This is different from “Protected,” which is stronger and is intended to hide the script contents. It is also different from “None,” which allows other application developers to customize the Script Include. The CAD topic here is application file protection and intellectual-property management in distributed applications. Read-only is useful when developers want consumers to inspect the implementation for transparency or troubleshooting but do not want them to modify the script values. Therefore, option C accurately describes Read-only protection behavior.

================

https://docs.servicenow.com/bundle/tokyo-platform-administration/page/administer/form-administration/concept/c_FormDesign.html

The Form Designer is a graphical interface for creating and customizing forms. The following statements are true for the Form Designer:

To add a field to the form layout, drag the field from the Fields tab to the desired destination on the form. This will add the field to the form view without changing the table definition.

To create a new field on a form’s table, drag the appropriate data type from the Field Types tab to the form and then configure the new field. This will create a new column on the table and add the field to the form view.

To remove a field from the form layout, hover over the field to enable the Action buttons, and select the Delete (X) button. This will remove the field from the form view but not from the table definition.

The following statement is false for the Form Designer:

To add a section to the form layout, drag it from the Field Types tab to the desired destination on the form. This is incorrect because sections are not available in the Field Types tab. To add a section, click the Add Section button on the toolbar or right-click on the form and select Add Section. References: Introduction to App Engine Studio for Developers, ServiceNow Studio Overview, Form Designer

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= < record_producer_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.

ServiceNow Developer Documentation on Modules and URL Arguments​.

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.

Application Access is a feature that allows you to control the access level of other application scopes to your application’s data tables. You can use Application Access to control the following database operations:

Create: This operation allows the user to create new records on the table. You can enable or disable this operation by selecting or clearing the Can create option.

Delete: This operation allows the user to delete existing records on the table. You can enable or disable this operation by selecting or clearing the Can delete option.

Read: This operation allows the user to view the records on the table. You can enable or disable this operation by selecting or clearing the Can read option.

Write: This operation allows the user to modify the records on the table. You can enable or disable this operation by selecting or clearing the Can write option.

The one database operation that cannot be controlled with Application Access is Query. Query is not an operation, but a method of the GlideRecord class that is used to retrieve records from the database on the server-side. Query is not part of the Application Access rules, but it is affected by the Access Controls and the user’s roles.

While record producers are powerful tools for creating records via the Service Catalog, they cannot natively redirect users after submission. Redirection typically requires script hacks or custom widget configurations.

From ServiceNow Docs (Catalog Scripting):

“By default, record producers return the user to the catalog homepage. Redirection requires scripting using producer scripts or custom client logic.”

" Schema map: Provides a graphical representation of the relationships between tables. "

https://docs.servicenow.com/bundle/tokyo-platform-administration/page/administer/table-administration/concept/c_TableAdministration.html

In Flow Designer, the unit that packages a set of related, reusable automation capabilities for a particular integration or application area is called a Spoke. A spoke is a scoped application that contains prebuilt actions, subflows, and supporting components designed to work together for a specific system, application, or record type. This structure helps developers and implementers reuse automation logic without rebuilding the same steps repeatedly, and it provides a governed way to distribute automation content. An Action is an individual reusable operation inside Flow Designer, not the container application. A Flow is an automation definition that runs based on a trigger, not a package of actions. “Bundle” is not the standard Flow Designer packaging term for these scoped sets of actions. Therefore, the correct scoped application type that contains tailored actions is a Spoke.

" Use an existing MID Server to connect to a Source Control repository. Linking or importing an application through a MID Server enables access to repositories behind a firewall. " https://docs.servicenow.com/bundle/tokyo-application-development/page/build/applications/concept/c_SourceControlIntegration.html

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

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

" A table that extends another table is called a child class, and the table it extends is the parent class " - this is about halfway down in this link below: https://docs.servicenow.com/en-US/bundle/tokyo-platform-administration/page/administer/table-administration/concept/table-extension-and-classes.html

https://docs.servicenow.com/bundle/paris-servicenow-platform/page/administer/flow-designer/concept/spokes.html

A spoke is a scoped application containing Flow Designer content dedicated to a particular application or record type. Flow Designer provides a set of core actions to automate Now Platform® processes. You can add application-specific core actions by activating the associated spoke.

Flow Designer is a no-code platform capability that lets you automate business processes in a single drag-and-drop design environment. Some of the features of Flow Designer are:

Add stages to a flow: You can define the stages of a flow to track its progress and status. Stages can be used to group actions, subflows, and conditions into logical units.

Call a flow from another flow or subflow: You can reuse existing flows or subflows by calling them from another flow or subflow. This allows you to modularize your automation and avoid duplication of logic.

Test a flow using the “Run as” feature: You can test a flow using the “Run as” feature to specify the user context and input parameters for the flow execution. This helps you to verify the functionality and performance of your flow before publishing it.

Flow Designer – No-Code Workflows - ServiceNow

Flow Designer - ServiceNow

Flow Designer Data Sheet - ServiceNow

In the SOAP Message feature set, we indicate variables using the following syntax: S{variable_name}. This allows us to pass a variable with the specified name from the SOAP message record to the web service function.

Tutorial: Handling a SOAP Response in ServiceNow | John Andersen

ServiceNow SOAP - Cheat Sheet Cheat Sheet by bibingokuldas - Download …

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

Enabling “Allow access to this table via web services” allows authenticated users with proper roles to access this table via REST/SOAP APIs.

From Development Handbook 4.0.4, p. 191:

" This setting allows web service access to a table, but still requires that users have appropriate roles and permissions through ACLs. "

Thus, access isn’t automatic — proper access controls still apply.

ServiceNow provides several methods for developers to publish and share applications once they are ready for distribution. The supported methods include:

Publish to an application repository: This method allows developers to publish their applications to a centralized repository, enabling easy distribution and installation across multiple ServiceNow instances. The application repository serves as a hub where applications can be stored and accessed by other instances.

snowunderground.com

Publish to the ServiceNow Store: Developers can submit their applications to the ServiceNow Store, a marketplace where applications are reviewed, certified, and made available to all ServiceNow customers. Publishing to the Store involves a certification process to ensure the application meets ServiceNow ' s standards.

support.servicenow.com

Publish to an update set: An update set is a container for capturing configuration changes in ServiceNow. Developers can publish applications to an update set, which can then be moved between instances, allowing for the transfer of application configurations and customizations.

servicenow.com

Options A (Publish to a spreadsheet), D (Publish to a local USB device), and F (Publish to a local drive) are not supported methods for publishing applications in ServiceNow. These options do not align with the platform ' s mechanisms for application distribution and deployment.

In scoped applications, client-side GlideRecord is not supported. The recommended pattern is to move the database query or server-side processing into a Script Include and call it from the client using GlideAjax. GlideAjax allows a client script to call server-side code asynchronously and return only the needed result to the browser. GlideForm is used to manipulate form fields, GlideDialogWindow is for dialog windows in older UI patterns, and GlideElement is not the replacement for client-side database access. From a CAD best-practice perspective, GlideAjax also avoids inefficient client-side database queries and supports better separation between client logic and server logic. Therefore, B is correct.

================

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

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.

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]

" 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

" 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/build/applications/task/t_SelectAnAppFromTheAppPicker.html

In ServiceNow, the GlideSystem (gs) object provides several methods for logging messages in server-side scripts. In a privately-scoped application, the following methods are commonly used:

A. gs.log(): This method logs a message to the system log (syslog table). It is a general-purpose logging method that allows developers to record informational messages.

E. gs.info(): This method logs informational messages to the system log. It is functionally similar to gs.log() but is specifically intended for informational messages.

The other options are not standard methods provided by the GlideSystem object:

B. gs.error(): This method does not exist in the GlideSystem API.

C. gs.debug(): This method does not exist in the GlideSystem API.

D. gs.logError(): This method does not exist in the GlideSystem API.

For more detailed information, refer to the official ServiceNow documentation on the GlideSystem API.

Web services are software systems that use standardized protocols and formats, such as XML and HTTP, to exchange data and messages between different applications or systems over the Internet or other networks12. Web services enable interoperability and integration among diverse software components, regardless of their programming languages, platforms, or architectures34.

References = 1: What are Web Services? - GeeksforGeeks 2: Web service - Wikipedia 3: What are Web Services? - Online Tutorials Library 4: What is a Web Service? | Webopedia

In the Application Navigator, visibility is evaluated at both the application menu level and the module level. A module can specify roles in its Roles field, but when that module Roles field is empty, the module does not add additional role requirements by itself. Instead, the user must still be able to see the application menu that contains the module. That means the effective gate becomes the application menu’s access configuration (including any required roles on the application menu). As a result, the module is visible to users who already have access to the application menu, because the module is not restricting access further. This behavior supports clean navigation design: define broad access at the application menu level, and only add module-level roles when you need to hide specific modules within an otherwise visible application menu. Options like “snc_internal” or “users with no roles” are not universally correct because module visibility is not determined by those conditions alone. The key rule is: if module Roles is empty, application menu access controls whether users can see the module.

A possible reason to build a custom app is to fulfill a specific use case on internal processes. For example, you may want to digitize a manual process that is not covered by an existing ServiceNow solution, such as managing inventory, tracking expenses, or scheduling events. Building a custom app on the Now Platform can help you automate workflows, improve data quality, and provide better user experiences. The other options are not valid reasons to build a custom app. To avoid using a code repository like GitHub or GitLab is not a reason to build a custom app, as you can still use source control integration with your custom app development. To create a custom integration for a 3rd party system is not a reason to build a custom app, as you can use integration tools such as IntegrationHub or REST APIs to connect with external systems without creating an app. To replace ServiceNow base tables is not a reason to build a custom app, as it is not recommended to modify or delete base tables that are essential for ServiceNow functionality. Reference: Build Custom Apps in ServiceNow – eBook

The Guided Application Creator (GAC) is a tool that helps you create applications on the ServiceNow platform by guiding you through the steps of defining the data model, user interface, and logic. When using the GAC, you can designate data tables in three ways:

Upload an existing PDF: You can upload a PDF file that contains the table schema and sample data. The GAC will parse the PDF and create the table and fields based on the file content.

Create a new table on the platform: You can create a new table on the platform by specifying the table name, label, and description. You can also add fields, indexes, and relationships to the table using the GAC.

Upload an existing spreadsheet: You can upload a spreadsheet file that contains the table schema and sample data. The GAC will parse the spreadsheet and create the table and fields based on the file content.

The other options are not valid ways to designate data tables when using the GAC. You cannot upload an existing word processing document or use a freeform database. You can use an existing table on the platform, but you cannot designate it as a data table. You can only use it as a reference table for lookup fields.