CAD Certified Application Developer - ServiceNow Question and Answers

ServiceNow Studio code search uses the default code search group to determine which application file types are searchable. To expand the supported file types, an administrator can create a new code search group that includes additional file types. This is cleaner than modifying a default table or changing unrelated metadata synchronization settings. The important CAD concept is that code search is metadata-driven and applies to searchable application file types, generally those extending sys_metadata. Creating a new code search group keeps the configuration controlled and avoids changing baseline behavior unnecessarily. Therefore, option A is the best answer for expanding supported Studio code search file types.

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

In ServiceNow, when developing within a privately-scoped application, certain logging methods are recommended for use in server-side scripts to ensure proper logging and debugging. The GlideSystem (gs) object provides several methods for this purpose:

gs.debug():

Description: Logs messages at the " Debug " level.

Usage: gs.debug( ' Debug message here ' );

Purpose: Useful for logging detailed information during development and troubleshooting. These messages are typically only visible when the system ' s logging level is set to " Debug. "

gs.error():

Description: Logs messages at the " Error " level.

Usage: gs.error( ' Error message here ' );

Purpose: Used to log error messages that indicate a problem that might still allow the application to continue running.

gs.warn():

Description: Logs messages at the " Warning " level.

Usage: gs.warn( ' Warning message here ' );

Purpose: Used to log potentially harmful situations that are not necessarily errors but may require attention.

gs.info():

Description: Logs messages at the " Information " level.

Usage: gs.info( ' Information message here ' );

Purpose: Used to log informational messages that highlight the progress of the application at a coarse-grained level.

Deprecated or Unsupported Methods in Scoped Applications:

gs.log():

Description: This method is not supported in scoped applications. It is restricted to the global scope and is not accessible from a private scope. Therefore, it should be avoided in privately-scoped applications.

An application admin is a role that grants full access to an application and its tables, scripts, and other components1. An application admin can create, modify, and delete any element of the application, as well as publish and install it2. An application typically has an application admin role that is automatically created and assigned to the application creator3.

References = 1: Application administration - ServiceNow Docs 2: Application admin role - ServiceNow Docs 3: Application roles - ServiceNow Docs

The statements that must evaluate to true for a user to pass an Access Control are:

Conditions configured in the Access Control must evaluate to true.

The user has one of the roles specified in the Required roles related list.

Scripts configured in the Access Control must evaluate to true.

An Access Control is a rule that determines whether a user can access a particular object or operation in ServiceNow. An Access Control consists of three elements: Conditions, Roles, and Script. Each element specifies a requirement that the user must meet to access the object or operation. If any of these elements return false, the Access Control denies access and stops evaluating the remaining elements. Therefore, for a user to pass an Access Control, all three elements must evaluate to true.

The other statements are not required for a user to pass an Access Control. Other matching Access Controls for the records do not need to evaluate to true, as only one matching Access Control needs to return true for access to be granted. The user does not need to be granted access through a business rule, as business rules are not part of Access Controls and do not affect their evaluation. Reference: Access control rules, Access Controls

A UI Action is a button, link, or choice that can be clicked by a user to perform an action, such as submitting a form or running a script. The following are UI Action types:

List choice. This is a UI Action that appears as a choice list on a list of records. It can be used to perform an action on multiple records at once, such as deleting or updating them.

Form button. This is a UI Action that appears as a button on a form. It can be used to perform an action on the current record, such as saving or approving it.

List banner button. This is a UI Action that appears as a button on the banner of a list of records. It can be used to perform an action on the entire list, such as exporting or printing it.

The following is not a UI Action type:

Form choice. This is not a UI Action type, but a field type. A form choice is a field that displays a choice list on a form. It can be used to select a value from a predefined set of options, such as priority or state. References: UI Actions, Field Types

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

The Guided Application Creator in ServiceNow provides several methods for creating tables within a new application. These options cater to different requirements and data sources:

Extend a Table (Option A):

Description: Create a new table that inherits fields and behaviors from

See list of triggers on right hand side of this webpage: https://docs.servicenow.com/en-US/bundle/tokyo-application-development/page/administer/flow-designer/reference/flow-triggers.html

The trigger types in Flow Designer are Application, Record, Schedule, and Topic. Outbound Email is not a trigger type, but an action type that can be used in a flow to send an email message1. References: Flow Designer Trigger Types

Update Sets group configuration changes for deployment across environments (e.g., from dev to test). They don’t track data or metrics.

From Development Handbook 4.0.4, p. 213:

“Update Sets are used to track and bundle changes, allowing developers to promote and test configuration updates between instances.”

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

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.”

You must script and configure all required behaviors Provided link has this statement: Extending an existing ServiceNow table means the new table inherits the parent table ' s columns as well as its business logic.

The following statements apply when extending an existing table:

The parent table’s Access Controls are evaluated when determining access to the new table’s records and fields. This is true because Access Control (ACL) rules are inherited from the parent table to the child table, unless the child table has its own ACL rules that override the parent table’s rules. ACL rules are used to restrict the access to the data and functionality of the ServiceNow platform based on the user’s roles and conditions.

The new table inherits the functionality built into the parent table. This is true because the new table inherits the business logic and the relationships from the parent table, such as Business Rules, Script Includes, UI Actions, UI Policies, and Reference Fields. Business logic and relationships are used to define the behavior and the structure of the data on the ServiceNow platform.

The new table inherits all of the fields from the parent table. This is true because the new table inherits the columns and the attributes from the parent table, such as Field Name, Data Type, Default Value, and Mandatory. Columns and attributes are used to define the properties and the characteristics of the data on the ServiceNow platform.

The following statement does not apply when extending an existing table:

You must script and configure all required behaviors. This is false because you do not have to script and configure all required behaviors when extending an existing table, as some of the behaviors are already inherited from the parent table, as explained above. However, you can script and configure additional or customized behaviors for the new table, such as adding new fields, creating new Business Rules, or modifying existing UI Actions. References: Table Extension, Access Control Rules

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

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

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

In ServiceNow, Modules are navigation elements that provide access to various parts of the platform, such as forms, lists, reports, or other application components. They are organized within Application Menus to create a structured and intuitive navigation hierarchy.

Key characteristics of Modules:

Part of Application Menus: Every module is contained within an application menu. This organization helps users navigate to different areas of the platform efficiently. For instance, the " Incident " application menu may contain modules like " Create New " or " All Incidents. "

Functionality: Modules can open various elements, including forms, lists, reports, or URLs. This flexibility allows modules to direct users to specific records, filtered lists, or external resources.

Association with Tables: While many modules are associated with specific tables (e.g., a module that displays a list of incidents is associated with the " Incident " table), it ' s not a strict requirement. Some modules may link to external URLs or perform actions not directly tied to a table.

Access Control: Access to modules is controlled through roles. Administrators can define which user roles have visibility and access to specific modules, ensuring that users only see modules relevant to their responsibilities.

For example, a module named " Active Incidents " under the " Incident " application menu might display a list of all active incident records. Access to this module can be restricted to users with the " itil " role, ensuring that only authorized personnel can view active incidents.

Delegated Development is intended to let administrators grant controlled development permissions to non-admin developers for a specific scoped application. Within that model, admins can allow delegated developers to work on application artifacts and administration tasks that are still limited to the application scope. One of the permitted areas is managing security artifacts, which includes creating and maintaining Access Controls (ACLs) and related security configuration for the application’s tables and resources. That aligns directly to option C. Administrators can also grant the permission to delete the scoped application, which aligns to option D and is treated as a high-impact capability that is explicitly controlled by delegated development permissions. By contrast, option A is not valid because delegated development is for scoped applications and does not grant authority to develop or deploy global applications. Option B is not a delegated development permission category; coalesce configuration is part of import/set-up behavior and is not represented as a delegated developer permission in the application development permission set.

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, when configuring a REST Message, the Endpoint specifies the URI (Uniform Resource Identifier) where the REST request is sent. This URI points to the resource on the external system that the REST message will interact with, whether it ' s to retrieve, update, create, or delete data.

Key Points:

Endpoint Definition: The Endpoint is a complete URL that includes the protocol (e.g., HTTP or HTTPS), the domain or IP address of the external server, and the specific path to the resource. For example: https://api.example.com/v1/resources.

Dynamic Endpoints: ServiceNow allows the use of variables within the Endpoint URL, enabling dynamic substitution at runtime. This is useful when the exact resource path or parameters need to be determined during execution.

Configuration in ServiceNow:

Navigate to " System Web Services " > " Outbound " > " REST Message. "

Create a new REST Message or select an existing one.

In the REST Message record, define the Endpoint URL in the " Endpoint " field.

Example Scenario:

If you are integrating ServiceNow with an external ticketing system to retrieve incident data, the Endpoint might be something like https://api.ticketingsystem.com/incidents/{incident_id}, where {incident_id} is a placeholder that gets replaced with the actual incident ID at runtime.

" Application developers must select an application as their current scope context. " https://docs.servicenow.com/bundle/tokyo-application-development/page/build/applications/task/t_SelectAnAppFromTheAppPicker.html

In ServiceNow, GlideForm is the client-side API used to interact with and manipulate a record form, including reading and writing field values, controlling visibility/mandatory/read-only behavior, and displaying messages to the user. The platform exposes GlideForm methods through a single global client-side object named g_form. ServiceNow documentation explicitly states that there is no constructor for the GlideForm class and that developers access GlideForm methods using the g_form global object available in client-side contexts such as Client Scripts and UI Policies. This makes g_form the correct and standard way to call GlideForm functions (for example, g_form.getValue(), g_form.setValue(), g_form.setDisplay(), etc.). The other options listed are not the documented GlideForm global object for standard client scripting in ServiceNow.

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.

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

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

The syntax used in a Record Producer script to access values from Record Producer form fields is producer.variable_name. A Record Producer is a type of catalog item that allows users to create records on any table from the service catalog. A Record Producer script is a server-side script that runs when a Record Producer is submitted, and can be used to set values or perform actions on the generated record. The producer object is a global object that represents the Record Producer form and its variables. The variable_name is the name of the variable defined in the Record Producer. References: [ServiceNow Docs - Record producers], [ServiceNow Docs - Record producer script]

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.

In ServiceNow, when importing data from external sources, the data is first loaded into an Import Set table, which acts as a staging area. To move this data into an existing ServiceNow table (known as the target table), a Transform Map is used. A Transform Map is a set of field mappings that define the relationships between fields in the Import Set table and fields in the target table. This mapping ensures that data is accurately transformed and transferred to the correct fields in the target table during the import process. Therefore, the correct answer is C. Transform Map.

The other options are not related to this specific function:

A. Business Service Management Map: This is not a standard term used in the context of data import and transformation in ServiceNow.

B. Data Sources: These define the origin of the data being imported but do not handle the field mapping between Import Set tables and target tables.

D. Schema Map Relationship Builder: This tool visualizes the relationships between tables in the database schema but is not used for mapping fields during data transformation.

For more detailed information, refer to the official ServiceNow documentation on Transform Maps.

Application Properties let developers expose configurable values (via system properties), so behavior can be changed without altering code.

From Development Handbook 4.0.4, p. 167:

“Use application properties to enable or disable features or change behavior without modifying scripts directly. This promotes modularity and flexibility.”

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]

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.

Flow Designer runs automation based on triggers. A primary trigger type is a Record trigger, which starts a flow when a record is created, updated, or created or updated. This matches option A and is one of the most common ways to automate application behavior using table data. Flow Designer also supports triggers tied to SLA-related events, enabling flows to react when an SLA is approaching breach or breaches, which aligns to option E in the way the platform exposes SLA timing events for automation. In addition, flows can be started by an inbound request through supported APIs, allowing external systems or scripts to invoke flow execution, which aligns to option F. By contrast, elevating to security_admin is a privileged security operation, not a Flow trigger; logging in as a specific user is an authentication/session activity rather than an automation trigger; and outbound email is typically an action that a flow can send, not an event that triggers a flow. The correct answers focus on documented Flow trigger categories rather than UI or security behaviors.

Recurring checks, like finding task records that are unassigned, are implemented using platform automation that runs on a schedule. ServiceNow provides two common development-aligned places for this type of logic. Scheduled Script Execution is a scheduled job mechanism that runs server-side scripts at defined intervals. Developers use it to query tables (such as Task) and take actions like updating fields, creating follow-up records, or sending notifications when conditions are met. This matches option C. For low-code automation, Flow Designer also supports scheduled triggers, allowing developers to run a flow at specific times or on a repeating schedule to perform checks and actions. This matches option A (Scheduled Flows). Discovery Schedules are specific to the Discovery feature set for scanning infrastructure and are not used for general task management checks. “System Schedules” is not the standard construct where custom recurring business logic is authored for application development; the platform’s scheduled logic is typically implemented through scheduled jobs (including script executions) and scheduled flow triggers.

The following is true for GlideUser (g_user) methods:

Can be used in Client Scripts, UI Policies, and UI Actions. This is true because GlideUser (g_user) methods are part of the client-side scripting APIs that provide information about the current user and the user’s preferences. Client Scripts, UI Policies, and UI Actions are all types of client-side scripts that run in the web browser and manipulate the user interface.

The following are not true for GlideUser (g_user) methods:

Can be used in Client Scripts and UI Policies only. This is false because GlideUser (g_user) methods can also be used in UI Actions, which are another type of client-side scripts that can be triggered by a user’s click on a button, link, or choice.

Can be used in Business Rules only. This is false because GlideUser (g_user) methods cannot be used in Business Rules, which are server-side scripts that run on the ServiceNow platform and manipulate the database. Business Rules use a different API to access the current user information, which is GlideSystem (gs).

Can be used in Business Rules, and Scripts Includes. This is false because GlideUser (g_user) methods cannot be used in Business Rules or Script Includes, which are both server-side scripts. Script Includes are reusable units of code that can be called from any server-side script. Script Includes also use GlideSystem (gs) to access the current user information. References: Client-Side Scripting APIs, GlideUser, Business Rules, Script Includes

The elements of an Access Control are evaluated in the following order: Conditions, Roles, Script. The Conditions are a set of criteria that must be met for the Access Control to apply. The Roles are a list of user roles that are required to access the object. The Script is an optional script that can further restrict or allow access based on custom logic. If any of these elements return false, the Access Control denies access and stops evaluating the remaining elements. Reference: Access control rules

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

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

The following is true for a Script Include with a Protection Policy value of Protected:

The Protection Policy is applied only if the application is downloaded from the ServiceNow App Store. This is true because the Protection Policy is a feature that allows developers to protect their Script Includes from being viewed or modified by other users when they distribute their applications through the ServiceNow App Store. The Protection Policy is only enforced when the application is installed from the App Store, not when it is developed or tested on the instance.

The following are not true for a Script Include with a Protection Policy value of Protected:

Any user with the protected_edit role can see and edit the Script Include. This is false because the protected_edit role is not related to the Protection Policy, but to the Access Control (ACL) rules. The protected_edit role allows users to edit protected fields on a table, such as the script field on the sys_script table, which stores the Business Rules. The Protection Policy does not use roles to control access to the Script Includes, but a cryptographic key that is generated when the application is published to the App Store.

The Protection policy option can only be enabled by a user with the admin role. This is false because the Protection policy option can be enabled by any user who has the application_admin role for the scoped application that contains the Script Include. The application_admin role grants full access to the application development and administration within the scope of the application.

The Protection Policy is applied only if the glide.app.apply_protection system property value is true. This is false because the glide.app.apply_protection system property is not related to the Protection Policy, but to the Application Restricted Caller Access (ARCA) feature. The ARCA feature allows developers to restrict the access to the Script Includes from other applications based on the caller’s scope. The glide.app.apply_protection system property determines whether the ARCA feature is enabled or disabled on the instance. References: Script Includes, Protect Script Includes, Application Restricted Caller Access

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

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

In ServiceNow, the Event Registry is a table that contains a record for every event recognized by the system. It allows ServiceNow to respond when these events are generated. By registering events, the system can automate activities such as triggering notifications or executing script actions when specific events occur. Therefore, the correct answer is A.

The other options are not accurate descriptions of the Event Registry:

B. The Event Log which lists all Events that have been generated: This describes the Event Log, not the Event Registry.

C. A Workflow which is launched every time an Event is generated; used to debug Events: This is not how the Event Registry functions.

D. The method used in server-side scripts to generate Events and pass parameters: This describes the gs.eventQueue() method, not the Event Registry.

For more detailed information, refer to the official ServiceNow documentation on the Event Registry.

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

ServiceNow provides multiple ways to show messages to users in the UI, and the correct method depends on whether the message is meant for the top of the form or next to a specific field. In the GlideForm client API, ServiceNow documents g_form.addInfoMessage(String message) as the method that adds an informational message to the top of the form. This is the standard client-side approach for showing an info banner at the top area of the current form and is commonly used in Client Scripts and UI Policies to inform users about guidance, rules, or results of client-side logic. ServiceNow’s GlideForm documentation specifically names this method and provides examples of its usage via g_form. By contrast, g_form.showFieldMsg() (and similarly named field-message functions) are used to display messages associated with a particular field location, not as a general blue banner at the top of the form. The option g_form.addInfoMsg() is not the documented default method name. Therefore, the correct answer is g_form.addInfoMessage().

https://docs.servicenow.com/bundle/tokyo-platform-security/page/administer/contextual-security/concept/access-control-rules.html

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.

Application developers can specify which ServiceNow page a user sees after submitting a new record using the Record Producer UI by writing a script in the Record Producer’s Script field: producer.redirect = “ < URL > ”;. This script sets the redirect property of the producer object to the URL of the desired page. For example, producer.redirect = “home.do”; will redirect the user to the homepage after submitting the record. The other options are not valid ways to specify the redirect page for a Record Producer. Reference: Populate record producer data and redirect users

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.

https://docs.servicenow.com/bundle/tokyo-application-development/page/script/useful-scripts/reference/r_DisplayFieldMessages.html

" Add instructional text and other design elements to your forms by using form annotations in Form Builder. " https://docs.servicenow.com/bundle/sandiego-application-development/page/administer/form-builder/task/create-form-annotations.html

Business Rules run server-side, so the correct APIs come from the GlideSystem object (gs) rather than client-side objects like g_form. In server-side scripting, the platform provides a standard way to retrieve the currently logged-in user’s identity. The method gs.getUserID() returns the sys_id of the user associated with the current session. This is commonly used in Business Rules for auditing logic, conditional processing, field stamping (for example, setting a custom “last processed by” field), or enforcing business rules based on user identity. The g_form object is a client-side API available in Client Scripts and UI Policies, so any option using g_form is invalid in a Business Rule context. Likewise, gs.getUserSysID() is not the documented method name for this purpose. Using the correct server-side API ensures the script executes reliably regardless of UI context (classic UI, workspace, mobile), because it relies on the session and not on the form rendering layer.

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.

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.

Publish an application to the application repository

4 Ways to Publish a ServiceNow Application

Publish applications to the ServiceNow Store

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

A Record Producer creates a target record from Service Catalog input. If the Record Producer script aborts record generation, ServiceNow does not create the produced record tracking entry in the Item Produced Record [sc_item_produced_record] table. This is different from simply redirecting the user or showing an error message. User notification depends on whether the developer explicitly adds a message, such as an error message, in the script. The key CAD concept is that aborting the database action prevents the generated record process from completing. Therefore, the most accurate option is A, because no produced-record entry exists when generation is stopped.

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

" 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

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]

Roles are used to control access to applications and modules in the application navigator. Each application menu or module has a role field that specifies which role is required to view it. Users who do not have the specified role or a role that contains it will not see the application menu or module. Roles can also be used to control access to other features and capabilities in ServiceNow, such as tables, fields, scripts, and workflows.

References = Enable or disable an application menu or module, Grant a role access to applications and modules, Controlling access to applications and modules.

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.

 The application development plan is a document that outlines the scope, objectives, deliverables, and timeline of a software project1. It should include the following business requirements and processes:

Data input/output: This describes what data is needed for the application to function, how the data is collected, stored, processed, and displayed, and what outputs are generated by the application2.

Business problem: This defines the problem or opportunity that the application aims to address, the current situation, the desired outcome, and the benefits of the solution3.

Process steps: This details the steps involved in the application development lifecycle, such as planning, designing, testing, deploying, and maintaining the application4.

Users/stakeholders: This identifies the people who will use, benefit from, or influence the application, their roles, responsibilities, and expectations, and how they will be involved in the project5.

References = 1: Application Development Lifecycle: Phases, Steps and Process3 2: Tips for Writing Business Requirements Documents2 3: Business Requirements Document Template: 7 Components1 4: Requirements Development Steps4 5: What is Business Process Documentation?: 10 Easy Steps to5

When designing forms in ServiceNow, the primary way to organize fields is by using Sections. Sections let developers group related fields into logical blocks, improving readability and guiding users through data entry in a consistent way. In form configuration tools, sections are structural layout elements that define how fields are arranged and presented, allowing developers to separate a form into meaningful areas such as “Requester Details,” “Assignment,” and “Resolution.” This helps reduce clutter on complex forms and supports usability best practices for enterprise applications. A Button is an action control and does not organize fields. A Related list shows records from other tables that are related to the current record; it supports navigation and context, but it does not organize the main record’s fields. Formatters are specialized UI components that can display additional information or UI elements on a form, but they are not the standard feature for grouping and organizing fields in the form layout. Because the question asks specifically about organizing fields during form design, Section is the correct choice.

In ServiceNow, the gs object provides a range of methods for logging messages on the server side. However, the availability of these methods can vary depending on whether the application is global or scoped.

gs.info(): This method is available in scoped applications and is used to log informational messages to the system log. It provides a way to record general information during script execution.

Options A (gs.log()), B (gs.print()), and D (gs.debugLog()) are not available in scoped applications. These methods are either restricted to global applications or do not exist in the ServiceNow API.

For more detailed information, refer to the official ServiceNow documentation on server-side scripting:

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.

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​.

The method call that returns true only if the currently logged in user has the catalog_admin role and in no other case is g_user.hasRoleExactly(‘catalog_admin’). This method checks if the user has exactly one role, and returns true if it matches the argument. The other methods return true if the user has one or more roles, or if the user has any role from a list of arguments. References: [ServiceNow Docs - GlideUser API], [ServiceNow Community - Difference between hasRole() and hasRoleExactly()]

Application scope is a foundational concept in ServiceNow application development. ServiceNow documentation describes application scoping as a protection mechanism that identifies and restricts access to an application’s files and data. In practice, scope defines an isolation boundary around an application’s artifacts, such as tables, scripts, UI components, and other resources. This boundary helps prevent unintended interference between applications and reduces the risk of naming collisions or cross-application impacts. The scope model also works together with Application Access settings, which allow administrators to specify what parts of an application are accessible to other applications. By default, scoped applications are designed to keep resources private unless explicitly shared through access settings or cross-scope privileges. Because of this, the primary purpose of scope is not backups or UI design control, and it is explicitly not meant to enable unrestricted updates across applications. Instead, scope exists to define and enforce boundaries so that an application’s resources remain isolated and protected unless intentionally exposed.

A Module Link type defines how the module opens in the content pane when the user clicks on it in the navigation pane1. The URL (from Arguments) link type allows you to specify a URL that opens the Application Properties page for the selected application2. The URL can include arguments that are evaluated at runtime, such as the application name or scope3.

References = 1: Module link types - ServiceNow Docs 2: Application properties - ServiceNow Docs 3: URL (from Arguments) - ServiceNow Docs

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]