CAD Sample Questions Answers

Create table from template is not an option for creating a table through the Guided Application Creator. The other options are available for creating a table in the app. Upload spreadsheet allows you to import data from an Excel file and create a table based on the spreadsheet columns and rows. Extend a table allows you to create a child table that inherits fields and behaviors from a parent table. Create table from scratch allows you to define your own fields and data types for a new table. Reference: Create tables

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

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

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

" 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

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.

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.

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.

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

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

Creating applications in ServiceNow can help businesses replace outdated, inadequate, custom business applications and processes, extend service delivery and management to all enterprise departments, and extend the value of ServiceNow by leveraging its platform capabilities and integrations1234.

References = 1: What are Application Services? - ServiceNow 2: What is Application Development? - ServiceNow 3: Custom Applications in ServiceNow - The Cloud People 4: Build Custom Apps in ServiceNow – eBook – ServiceNow

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.

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

In ServiceNow, UI Actions are elements that facilitate user interaction within the platform, enabling users to perform specific actions such as form submissions, record updates, or triggering workflows. The valid types of UI Actions include:

Form Button: A button displayed on a form that, when clicked, executes a defined action.

Form Context Menu: An option added to the context menu of a form, providing additional actions related to the form ' s record.

Form Link: A hyperlink on a form that directs users to another page or executes a script.

List Banner Button: A button displayed in the banner area of a list, allowing actions to be performed on multiple records simultaneously.

List Choice: An option added to the list context menu for individual records, enabling actions on a selected record.

List Link: A hyperlink in a list that directs users to another page or executes a script.

Record Navigation Button: Buttons that facilitate navigation between records, such as Next and Previous buttons.

Options like " Workflow action " and " Form choice " are not recognized as standard UI Action types in ServiceNow.

For comprehensive details, refer to the official ServiceNow documentation on UI Actions.

ServiceNow provides several methods to install applications onto an instance, each suited to different scenarios:

Import an Application from an XML File (Option A):

Description: Developers can export an application as an XML file and then import it into another ServiceNow instance.

Use Case: This method is commonly used for moving applications between instances, such as from development to production.

Procedure:

Navigate to " System Applications " > " Applications. "

Click on the " Import " button.

Upload the XML file of the application.

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

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

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

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

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

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

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.

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

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

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

The statement that is true for this script fragment is that the method returns true if the currently logged in user has the x_my_app_user role or the admin role. The g_user.hasRole() method is a client-side method that checks whether the current user has a specified role or set of roles. If no role is specified, it returns true if the user has any role. If one or more roles are specified, it returns true if the user has any one of the specified roles. However, this method always returns true if the user has the admin role, regardless of the role parameter. Therefore, in this case, the method returns true if the user has either the x_my_app_user role or the admin role. Reference: User Object Cheat Sheet, Checking user permissions

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

When creating a table in a privately-scoped application, four Access Controls are automatically created for the table. These Access Controls define the permissions for the four basic operations on the table: Create, Delete, Read, and Write. The Create operation allows the user to create new records on the table. The Delete operation allows the user to delete existing records on the table. The Read operation allows the user to view the records on the table. The Write operation allows the user to modify the records on the table. By default, these Access Controls grant access to the admin role and the application scope. You can modify or delete these Access Controls as needed.

The other options are not valid Access Controls for a table. Insert, Query, and Update are not operations, but methods of the GlideRecord class that are used to manipulate records on the server-side. They are not part of the Access Control rules.

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.

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.

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

The following are debugging strategies for client-side scripts, which run in the web browser and manipulate the user interface:

g_form.addInfoMessage(). This is a client-side API that displays an information message at the top of the form.

Field Watcher. This is a debugging tool that displays the current and previous values of one or more fields on a form.

jslog(). This is a client-side API that writes a message to the browser console.

The following is not a debugging strategy for client-side scripts, but for server-side scripts, which run on the ServiceNow platform and manipulate the database:

gs.log(). This is a server-side API that writes a message to the system log. References: Client-Side Scripting APIs, Debugging Client Scripts

The Application Repository is a central location for storing, managing, and distributing custom applications developed on the Now Platform.

From Developer Site > App Repo:

“The ServiceNow Application Repository stores custom applications and enables developers to distribute applications across multiple instances in their organization.”

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

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

Application Access is a feature that allows you to control the access level of other application scopes to your application’s data tables. By setting the Accessible from field value to This application scope only, you can restrict the access to your data tables to only your application scope. This means that other application scopes cannot create, read, write, or delete records on your data tables, unless they have explicit permissions through Access Controls or other means.

The ServiceNow Store is a marketplace for free and paid certified ServiceNow applications and integrations. The ServiceNow Store provides customers with access to Now Certified enterprise workflow apps from partners that complement and extend ServiceNow products and solutions. Customers can browse, try, buy, and deploy apps and integrations that suit their needs and enhance their ServiceNow experience. The ServiceNow Store is not the source for ServiceNow Community created developer content, as that is available on the Developer Portal or the Share site. The ServiceNow Store is not a downloadable content ServiceNow script archive, as that is available on the Script Library or the Script Repository. The ServiceNow Store is not an alternate name for the ServiceNow Developer Share site, as that is a separate site where developers can share applications, code snippets, UI pages, etc. Reference: ServiceNow Store

g_user is a global object available only in the client-side environment (Client Scripts, UI Policies, UI Actions).

From Development Handbook 4.0.4, p. 204:

“g_user is only available client-side. It returns session-specific info like roles and user ID. Not usable in Business Rules or Script Includes.”

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

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

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

 It is best practice to define the business requirements and the process(es) an application will manage as part of the application development plan. The following are some of the considerations to document as part of the business process:

Business problem. This is the description of the problem or opportunity that the application is intended to address or exploit. It should include the background, context, scope, and objectives of the problem or opportunity.

Data input/output. This is the specification of the data that the application will need to collect, store, manipulate, and display. It should include the data sources, formats, validations, transformations, and integrations of the data.

Users/stakeholders. This is the identification of the users and stakeholders who will be involved in or affected by the application. It should include the roles, responsibilities, expectations, and needs of the users and stakeholders.

Process steps. This is the definition of the steps and activities that the application will perform or support. It should include the inputs, outputs, triggers, conditions, and outcomes of each step or activity.

The following are not some of the considerations to document as part of the business process:

Project schedule. This is the estimation of the time and resources required to complete the application development project. It should include the milestones, deliverables, dependencies, and risks of the project. This is not part of the business process, but part of the project management plan.

Database capacity. This is the measurement of the amount of data that the application will generate and store in the database. It should include the data volume, growth rate, retention policy, and backup strategy of the data. This is not part of the business process, but part of the technical design and architecture of the application.

Available licenses. This is the number and type of licenses that the application will consume or require from the ServiceNow platform. It should include the license model, cost, and allocation of the licenses. This is not part of the business process, but part of the financial and legal aspects of the application. References: Application Development Process, Business Process Analysis

The Event Registry is a table that stores the definitions of all the Events that can be triggered or processed by the ServiceNow system1. The Event Registry allows ServiceNow to react when Events are generated by executing actions such as sending notifications, running scripts, or starting workflows2. The Event Registry also provides information about the Event parameters, description, and source3.

References = 1: Event Registry - ServiceNow Docs 2: Event Management - ServiceNow Docs 3: Event Registry form - ServiceNow Docs

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

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

ServiceNow notifications can sometimes be triggered close together for the same record and the same recipients, which can lead to redundant or conflicting messages. To control this, the Notification record includes a Weight field. ServiceNow documentation explains that when multiple notifications are generated for the same target table record and the recipients overlap, the system compares the notifications using the Weight value and sends only the notification with the highest weight. This allows administrators and developers to prioritize the most important notification when multiple are eligible to fire. A common example in the documentation is when an incident is updated (triggering an “commented” notification) and then closed shortly after (triggering a “closed” notification). If both would go to the same user, ServiceNow will select the one with the higher weight, ensuring users receive the most relevant final message instead of multiple emails. This behavior is the intended purpose of Weight: reduce notification noise and prevent conflicts by giving precedence to the highest-weight notification.

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

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.

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]

https://docs.servicenow.com/bundle/tokyo-application-development/page/script/server-scripting/concept/c_ServerScripting.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

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

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

ServiceNow Studio is used to develop and manage application artifacts within a scoped application, including server-side logic that runs when database operations occur. “Customizing system behavior through database actions” points directly to server-side automation triggered by record operations such as insert, update, delete, and query. The platform feature designed for that purpose is Business Rules, which execute on the server in response to database events and can validate data, set field values, enforce policies, or initiate additional processing. While Studio can also include other file types such as Client Scripts, UI Policies, and ACLs, those are not primarily described as “database actions.” Client Scripts and UI Policies are primarily UI and client behavior controls, and ACLs control security access. Business Rules are the canonical mechanism for database-triggered behavior and are the best match to the question’s wording. Therefore, the file type aligned to customizing system behavior through database actions is Business Rules (sys_script).

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

ServiceNow provides the Schema Map as the platform feature specifically designed to display a graphical representation of how tables relate to one another. In application development, tables commonly extend other tables and also reference other tables through reference fields. The Schema Map visualizes these relationships so developers can quickly understand the structure of the data model, including parent-child extensions and reference connections. This is especially useful when you are designing an application’s data model, troubleshooting why a field appears on multiple tables, or assessing the impact of adding a new relationship. The Schema Map is not a general “graphical user interface” concept; it is a dedicated view focused on the database schema. Likewise, a “dependency view” may exist for other platform features (such as dependency relationships for services or configuration items), but it is not the standard tool used to explore table-to-table schema relationships during application development. Because the question asks for a graphical view of relationships among tables, the correct documented feature is Schema Map.

To allow a module to open a form for new record insertion, the Link type should be set to “Create new record” or similar.

From Platform App Design Docs:

“Modules control navigation behavior via the Link type setting. To insert records, use the ' Create record ' or ' New record ' link type.”

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

Understanding Scoped Applications:Scoped applications in ServiceNow are designed to isolate and protect application-specific code and data. Server-side scripts within scoped applications can use the gs (GlideSystem) object for logging and debugging purposes. However, not all gs methods are appropriate or valid for scoped applications.

Valid Logging Methods in Scoped Applications:

gs.info():This method logs informational messages to the system log. It is commonly used for general-purpose logging when developers need to track execution flow or display debug data. Example:

gs.info( ' This is an informational log message. ' );

gs.error():This method logs error messages to the system log. It is used to indicate problems or issues encountered during script execution. Example:

gs.error( ' An error occurred during script execution. ' );

Incorrect Options Explained:

gs.debug() (Option B): This method is not valid in scoped applications. It is a legacy logging method available in the global scope but restricted in scoped applications.

gs.iog() (Option C): This is a typographical error and not a valid gs method in ServiceNow.

gs.logError() (Option E): This is not a recognized ServiceNow API method. To log errors, gs.error() is used instead.

Best Practices for Logging:

Logging should be meaningful and avoid unnecessary entries to keep logs clean and manageable.

Avoid excessive use of logging in production environments, as it can clutter the system logs and potentially degrade performance.

ServiceNow Developer Documentation on GlideSystem (gs)​.

SN Pro Tips on debugging and logging practices in scoped applications​.

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.

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

Inbound Action scripts are server-side scripts that run when an email is received by the system. They can use the current object to access the record that is created or updated by the email, and the email object to access the properties and methods of the email message. The previous and event objects are not available in Inbound Action scripts. The producer object is only available in Record Producer scripts, which are used to create records from a service catalog item.

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

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