Practice Free CAD Certified Application Developer - ServiceNow Exam Questions Answers With Explanation

Self-invoking. Learn JavaScript!

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

In ServiceNow, Access Controls (ACLs) determine the permissions required for users to access or modify data. For a user to pass an Access Control, the following conditions must be met:

Conditions configured in the Access Control must evaluate to true: Access Controls can have specific conditions set in the " Condition " field. These conditions are evaluated against the current record, and must return true for the Access Control to grant access.

The user has one of the roles specified in the Required roles related list: Access Controls can specify certain roles that a user must possess to gain access. If the user holds at least one of these roles, this criterion is satisfied.

Scripts configured in the Access Control must evaluate to true: Access Controls can include scripts that perform more granular checks. The script must execute without errors and return true for the user to pass the Access Control.

Option A is incorrect because Business Rules do not grant access; they are server-side scripts that execute based on record operations but do not control security permissions.

Option D is misleading. Each Access Control is evaluated independently. While multiple Access Controls can apply to a single operation, passing one does not inherently grant access unless it is the most specific match.

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

servicenow.com

In ServiceNow, Business Rules are server-side scripts that execute whenever a record is inserted, updated, deleted, or queried. However, certain actions can be configured without writing any script, using the Business Rule ' s user interface options.

The primary actions that can be configured without scripting are:

Set field values: This allows administrators to specify new values for fields when the Business Rule conditions are met. This is configured in the " Actions " tab of the Business Rule form, where specific fields and their desired values can be set without any scripting.

Add message: Administrators can configure a message to be displayed to the user when the Business Rule executes. This is done by selecting the " Add message " checkbox and providing the desired message text.

Options C (Set field values and write to the system log) and D (Set field values and generate an event) would require scripting. Writing to the system log involves using server-side APIs like gs.log(), and generating an event requires calling event generation methods—both necessitate scripting.

For more detailed information, refer to the official ServiceNow documentation on Business Rules:

servicenow.com

Configuring the label of a field in a child table changes the label only on that table, not on the base table or the parent table. The base table is the table that contains the common fields for all the extended tables, and the parent table is the table that is directly extended by the child table. The label of a field on the base table or the parent table can be different from the label on the child table. References: [ServiceNow Docs - Table extension], [ServiceNow Community - How to change field label in child table]

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]

The fastest way to create and configure a Record Producer is to open the table in the Table records and select the Add to Service Catalog Related Link. This will automatically create a Record Producer with the same fields as the table and add it to the Service Catalog. You can then modify the Record Producer as needed. The other options require more steps and manual configuration. Reference: Create a record producer

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

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.

One of the uses of the ServiceNow REST API Explorer is to create sample code for sending REST requests to ServiceNow. The REST API Explorer is a tool that allows you to discover and test the ServiceNow REST APIs. You can select an API endpoint, set the HTTP method, parameters, headers, and body, and then execute the request. The REST API Explorer will show you the response status, headers, and body, as well as generate sample code for various languages and frameworks, such as cURL, Java, JavaScript, Node.js, Python, Ruby, and more. References: [Use the REST API Explorer - Product Documentation: Tokyo - ServiceNow], [Introduction to Scripted REST APIs - ServiceNow Developers]

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.

A Display Business Rule has access to the current, g_scratchpad, and GlideSystem objects, but not the previous object. The previous object is only available to Before Business Rules4. References: Business Rule API

https://docs.servicenow.com/bundle/tokyo-application-development/page/script/business-rules/concept/c_BusinessRules.html

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.

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

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

Application Files are ServiceNow artifacts comprising an application. An application is a group of files and data that work together to provide a service or functionality. An application file is a specific type of file that belongs to an application, such as a table, a script, a form, a business rule, a UI action, etc. Application files define the structure, logic, and interface of the application. An XML export of an application’s table records, XML exports of an application’s Update Set, and CSV files containing data imported into an application are not examples of application files, as they are data formats that can be used to transfer or store information related to an application, but not the application itself. Reference: Application Files

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

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.

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

ServiceNow is optimized for building applications that manage structured data in tables and provide consistent user experiences through lists and forms. A core reason to develop on the platform is when the solution naturally fits the record-based model: users create, review, and update records through forms, and those records drive reporting, auditing, and process automation. That makes option C a direct match to how ServiceNow applications are designed and delivered. Another primary platform strength is workflow automation, including Flow Designer, approvals, task orchestration, notifications, and integration actions that coordinate work across teams and systems. If the solution requires repeatable, governed process automation, option D aligns with the platform’s purpose and capabilities. In contrast, “multimedia features” is not a platform driver for application development; while media can be displayed, it is not the typical reason to choose ServiceNow. Similarly, requiring low-level programming libraries is generally a mismatch, since ServiceNow development focuses on platform APIs and configuration patterns rather than direct access to low-level system libraries.

gs.print() and gs.log() are older and not available in scoped applications, whereas gs.debug(), gs.info(), gs.warn(), gs.error() work in both scoped applications and global are therefore are more versatile going forward in future versions.

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

The ServiceNow platform is designed to create applications that use forms, workflow, and reporting to solve business problems. Forms are used to interact with data stored in tables, workflow is used to automate and orchestrate processes, and reporting is used to visualize and analyze data. The platform does not require low-level programming libraries or multimedia features, as it provides standard tools and technologies for application development.

References = ServiceNow Certified Application Developer Exam Specification, Application Development Platform – ServiceNow

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

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

Create:

Description: Permission to insert new records into a table.

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

Update:

Description: Permission to modify existing records in a table.

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

Other Operations:

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

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

Incorrect Options:

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

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

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.

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.

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

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.

" 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

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 ServiceNow, when an event is generated using the gs.eventQueue() method, the system can respond in several ways:

B. Email Notification: Events can trigger email notifications. By associating an event with a notification, the system can send emails to specified recipients when the event occurs.

E. Script Action: Script Actions are server-side scripts that execute in response to events. They allow developers to define custom behaviors that should occur when specific events are fired.

The other options are not appropriate responses to events generated by gs.eventQueue():

A. UI Policy: UI Policies are used to dynamically change the behavior of fields on forms in the user interface and are not triggered by events.

C. Client Script: Client Scripts run on the client side (in the user ' s browser) and are not directly triggered by server-side events.

D. Scheduled Script Execution (Scheduled Job): Scheduled Jobs are scripts that run at specified times or intervals and are not triggered by events.

For more detailed information, refer to the official ServiceNow documentation on Responding to Events.

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

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

" 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

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

When evaluating Access Controls, ServiceNow searches and evaluates:

From the most specific match to the most generic match. This is the correct answer because ServiceNow follows a top-down approach when evaluating Access Control (ACL) rules, which are used to restrict the access to the data and functionality of the ServiceNow platform based on the user’s roles and conditions. ServiceNow starts with the most specific match, which is the field-level ACL rule, then moves to the table-level ACL rule, and finally to the global or * ACL rule. ServiceNow grants access if any of the ACL rules evaluates to true, and denies access if all of the ACL rules evaluate to false.

The following are not correct descriptions of how ServiceNow searches and evaluates Access Controls:

Only for matches on the current table. This is not correct because ServiceNow does not only look for matches on the current table, but also on the parent tables and the global or * table. For example, if there is no ACL rule for the incident table, ServiceNow will look for an ACL rule for the task table, which is the parent table of the incident table, and then for the global or * table, which is the parent table of all tables.

Only for matches on the current field. This is not correct because ServiceNow does not only look for matches on the current field, but also on the table that contains the field and the global or * table. For example, if there is no ACL rule for the short_description field on the incident table, ServiceNow will look for an ACL rule for the incident table, and then for the global or * table.

From the most generic match to the most specific match. This is not correct because ServiceNow does not follow a bottom-up approach when evaluating Access Controls, but a top-down approach, as explained above. References: Access Control Rules, ACL Evaluation Order

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

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

When a ServiceNow instance requests information from a web service, ServiceNow is the web service consumer. A web service consumer is an application that sends requests to a web service provider and receives responses from it. A web service provider is an application that exposes its functionality as web services. A web service publisher is a person or organization that publishes web services for others to use. A web service specialist is a person who has expertise in developing or using web services. Reference: Web services

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.

In ServiceNow, a Record Producer is a specific type of catalog item that enables users to create task-based records through a simplified interface.

servicenow.com

To create a module that directs users to a Record Producer UI:

Link Type Selection: Choose " URL (from Arguments:) " as the Link Type. This option allows you to specify a direct URL, enabling the module to open the desired Record Producer interface.

URL Configuration: In the " Arguments " field, input the URL that points directly to the Record Producer. This URL typically follows the format:

/record_producer.do?sys_id= < sys_id_of_record_producer >

Replace < sys_id_of_record_producer > with the actual sys_id of the Record Producer you intend to open.

By configuring the module this way, users accessing it will be presented with the Record Producer ' s user-friendly interface, facilitating the creation of new records without navigating through the standard form UI.

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.

" 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

When creating a table, the Create module field allows you to automatically create a module for the table in the application menu. The default behavior of the new module is to display a list of all records from the table. This can be changed later by editing the module properties and specifying a different link type, such as form, URL, or script.

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.

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

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 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]

A Module in ServiceNow is a navigational element within an Application Menu that directs users to specific records, lists, forms, or reports.

Option A (Correct): Modules always belong to an Application Menu, providing structured navigation.

Option B (Incorrect): Modules can link to pages, reports, and URLs, not just tables.

Option C (Incorrect): Modules can open forms, lists, dashboards, and external URLs.

Option D (Incorrect): Modules can be restricted by roles, limiting visibility and access.

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.

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

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

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

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

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

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

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

Catalog Client Scripts and Catalog UI Policies are the client-side scripts that apply to Record Producers. Catalog Client Scripts allow you to add or modify functionality on a catalog item or record producer form. Catalog UI Policies dynamically change information on a catalog item or record producer form. UI Scripts, UI Actions, Client Scripts, and UI Policies do not apply to Record Producers. Reference: Catalog client scripts, Catalog UI policies

In ServiceNow Studio, delegated developers can work with update sets for assigned applications, but the mechanism for packaging changes for deployment is the Publish button. The Update Set Picker is used to switch between update sets, not to package the application changes. Export to XML is an administrative update set activity and is not the Studio control described in this question. Delegated development separates development and deployment permissions, so administrators can grant selected users permission to publish to an update set, application repository, or Store. For this question, the phrase “package changes for deployment” maps directly to the Publish button in Studio. Therefore, D is correct.

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

When a new application table is created and the option to create a module is used, ServiceNow creates a list module for that table in the application menu. The default module name is based on the plural form of the application or table label, so users see a natural list-style module name in the Application Navigator. The “U_” or “X_” style prefixes relate to technical table names and scoped naming, not to the user-facing module title. The same name as the application is normally used for the application menu, not the list module. This is why option B is the correct CAD answer.

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

In ServiceNow, tables can extend other tables, inheriting all fields and functionalities from the parent table. These inherited fields are integral to the structure and behavior of the child table.

A. No, inherited fields cannot be deleted from a child table: This is correct. Inherited fields are part of the child table ' s schema due to its extension of the parent table. Removing these fields would disrupt the inherent structure and relationships defined by the table hierarchy.

B. Yes, but only if they are text fields: This is incorrect. The data type of the field does not permit the deletion of inherited fields.

C. Yes, select the red X in the left-most column in the table definition: This is incorrect. Inherited fields do not have a delete (red X) option in the table definition, as they are not directly created on the child table.

D. Yes, but only if there has never been any saved field data: This is incorrect. The presence or absence of data does not affect the ability to delete inherited fields.

To modify the structure of inherited fields, consider the following approaches:

Field Visibility: Use client scripts or UI policies to hide the inherited fields on forms where they are not needed. This approach maintains data integrity while tailoring the user interface to specific requirements.

Form Layout Configuration: Adjust the form layout to remove inherited fields from specific views, ensuring they are not displayed to users in contexts where they are irrelevant.

These methods allow customization of the user experience without altering the underlying table schema or violating the inheritance principles established in the data model.

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.

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

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

In ServiceNow, the Caller Access field is used to define the level of access that external scripts or applications have to a particular script include or application resource. The valid options for the Caller Access field are:

None: No special restrictions are applied; the resource is accessible as defined by other security settings.

Caller Restriction: Limits access to the resource, allowing only specified callers or applications to invoke it.

Caller Tracking: Enables tracking of which callers are accessing the resource, providing an audit trail for monitoring purposes.

Options such as " Accessible from, " " Allow Configuration, " and " Caller Permission " are not valid selections for the Caller Access field.

For more detailed information, refer to the official ServiceNow documentation on Restricted Caller Access Privileges.

In ServiceNow, the Application Picker is a tool that allows developers to select the active application scope. When an application is selected from the Application Picker, it sets the Application Scope to that application. This means that any configurations, scripts, or customizations made will be associated with the selected application ' s scope. Therefore, the correct answer is D.

The other options are incorrect:

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

B. Global is a reserved application which does not appear in the Application Picker: The Global application does appear in the Application Picker and can be selected.

C. Selecting an application from the Application Picker does not set the Application Scope: Selecting an application does set the Application Scope.

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

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

In ServiceNow, Application Files are configuration records that define the various components and logic that constitute an application. These include artifacts such as:

Business Rules

Client Scripts

UI Actions

Script Includes

Tables and Fields

Workflows

These artifacts collectively define the functionality and behavior of the application. When an application is developed, ServiceNow automatically creates and manages these Application Files to represent the application ' s components.

Option C is correct because Application Files are the fundamental building blocks that comprise a ServiceNow application, representing its various components and configurations.

Options A, B, and D are incorrect:

A: XML exports of an Update Set represent changes made to an instance but are not synonymous with Application Files.

B: CSV files are typically used for data import/export and do not represent the configuration components of an application.

D: An XML export of table records pertains to data within a table, not the configuration artifacts that define application behavior.

 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