{"id":15630,"date":"2026-09-18T06:06:42","date_gmt":"2026-09-18T06:06:42","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=15630"},"modified":"2026-09-18T06:06:42","modified_gmt":"2026-09-18T06:06:42","slug":"servicenow-cad-practice-test-questions-and-exam-dumps-part20-q381-400","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/servicenow-cad-practice-test-questions-and-exam-dumps-part20-q381-400\/","title":{"rendered":"ServiceNow CAD Practice Test Questions and Exam Dumps Part20 Q381-400"},"content":{"rendered":"

<\/h1>\n

View Full <\/b>ServiceNow CAD Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/h2>\n

 <\/p>\n

Question 381<\/b><\/h3>\n

Which ServiceNow feature is primarily used to control which records and fields users can access?<\/b><\/p>\n

    \n
  1. UI Policy<\/span><\/li>\n
  2. Business Rule<\/span><\/li>\n
  3. Access Control List (ACL)<\/span><\/li>\n
  4. Client Script<\/span><\/li>\n<\/ol>\n

    Correct Answer: 3<\/b><\/p>\n

    Explanation<\/b><\/h3>\n

    Access Control Lists (ACLs) are the primary security mechanism in ServiceNow for controlling access to records and fields. An ACL can define whether a user is allowed to perform operations such as create, read, write, or delete. ACL conditions and scripts can evaluate roles, users, and record information before granting access. Table-level ACLs control access to records, while field-level ACLs can restrict individual fields. UI Policies and Client Scripts can change the user interface, but they should not be considered the main security mechanism because client-side logic can be bypassed. Therefore, ACLs provide the appropriate server-side authorization layer for protecting application data.<\/span><\/p>\n

    Question 382<\/b><\/h3>\n

    Which method is commonly used with GlideRecord to retrieve a single record using its <\/b>sys_id<\/b>?<\/b><\/p>\n

      \n
    1. get()<\/span><\/li>\n
    2. next()<\/span><\/li>\n
    3. query()<\/span><\/li>\n
    4. fetch()<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1<\/b><\/p>\n

      Explanation<\/b><\/h3>\n

      The GlideRecord <\/span>get()<\/span> method is commonly used when a script needs to retrieve one specific record, especially when the <\/span>sys_id<\/span> is known. For example, <\/span>gr.get(‘sys_id’)<\/span> attempts to load the corresponding record into the GlideRecord object. The <\/span>query()<\/span> method executes a query and is normally followed by <\/span>next()<\/span> to iterate through returned records. The <\/span>next()<\/span> method moves the GlideRecord pointer to the next result. <\/span>fetch()<\/span> is not the standard GlideRecord method for retrieving a ServiceNow record. Using <\/span>get()<\/span> is therefore the most direct approach when the objective is to retrieve a specific record by its unique identifier.<\/span><\/p>\n

      Question 383<\/b><\/h3>\n

      Which Client Script type executes when a user changes the value of a field on a form?<\/b><\/p>\n

        \n
      1. onLoad<\/span><\/li>\n
      2. onSubmit<\/span><\/li>\n
      3. onDisplay<\/span><\/li>\n
      4. onChange<\/span><\/li>\n<\/ol>\n

        Correct Answer: 4<\/b><\/p>\n

        Explanation<\/b><\/h3>\n

        An <\/span>onChange<\/span> Client Script runs when the value of a specified field changes on a form. It is useful when the application needs to respond dynamically to user input. For example, changing a category field could cause another field to become mandatory or update its available choices. An <\/span>onLoad<\/span> Client Script runs when the form loads, while an <\/span>onSubmit<\/span> Client Script executes when the user attempts to submit the form. <\/span>onDisplay<\/span> is not one of the standard Client Script types. Client Scripts primarily operate in the browser, so they are useful for improving form behavior and user experience rather than enforcing server-side security.<\/span><\/p>\n

        Question 384<\/b><\/h3>\n

        What is the primary purpose of a Transform Map in an Import Set process?<\/b><\/p>\n

          \n
        1. To define how imported data is transformed into target table records<\/span><\/li>\n
        2. To create application roles automatically<\/span><\/li>\n
        3. To control form visibility<\/span><\/li>\n
        4. To schedule database backups<\/span><\/li>\n<\/ol>\n

          Correct Answer: 1<\/b><\/p>\n

          Explanation<\/b><\/h3>\n

          A Transform Map defines how data from an Import Set table is mapped and transformed into records in a target ServiceNow table. It specifies source-to-target field mappings and can include transformation scripts, field actions, and coalesce configuration. During the transformation process, ServiceNow uses these rules to determine how imported information should be inserted or updated. Transform Maps are therefore an important part of data migration and integration workflows. They do not primarily manage form visibility, application roles, or database backups. When importing external data into ServiceNow, administrators and developers use Transform Maps to control how the incoming data is processed and stored in the target table.<\/span><\/p>\n

          Question 385<\/b><\/h3>\n

          Which server-side API is commonly used to perform aggregate calculations such as COUNT or SUM?<\/b><\/p>\n

            \n
          1. GlideRecord<\/span><\/li>\n
          2. GlideAggregate<\/span><\/li>\n
          3. GlideForm<\/span><\/li>\n
          4. GlideUser<\/span><\/li>\n<\/ol>\n

            Correct Answer: 2<\/b><\/p>\n

            Explanation<\/b><\/h3>\n

            GlideAggregate<\/span> is designed for performing database aggregation operations in ServiceNow. It can calculate values such as COUNT, SUM, MIN, MAX, and AVG and can group results when required. For example, a developer can use GlideAggregate to count incidents by priority without retrieving every individual incident record into memory. <\/span>GlideRecord<\/span> is primarily used for querying and manipulating individual records. <\/span>GlideForm<\/span> is a client-side API used for controlling forms, while <\/span>GlideUser<\/span> provides information about the current user. Using GlideAggregate can also improve efficiency because aggregation is performed by the database rather than requiring the script to process every record individually.<\/span><\/p>\n

            Question 386<\/b><\/h3>\n

            What is the main purpose of a Script Include?<\/b><\/p>\n

              \n
            1. To define database indexes<\/span><\/li>\n
            2. To configure form layouts<\/span><\/li>\n
            3. To store reusable server-side JavaScript logic<\/span><\/li>\n
            4. To create application menus<\/span><\/li>\n<\/ol>\n

              Correct Answer: 3<\/b><\/p>\n

              Explanation<\/b><\/h3>\n

              A Script Include is used to store reusable server-side JavaScript code in ServiceNow. Developers commonly place functions or classes in Script Includes so the same logic can be called from multiple server-side scripts. This improves maintainability and reduces duplication. Script Includes can also be configured as client-callable when appropriate, allowing client-side scripts to communicate with server-side logic through mechanisms such as GlideAjax. Script Includes are not intended primarily for defining database indexes, configuring form layouts, or creating application menus. Properly designed Script Includes help organize application logic and support reusable, modular development within ServiceNow applications.<\/span><\/p>\n

              Question 387<\/b><\/h3>\n

              Which Business Rule timing is generally appropriate when a record must be modified before it is written to the database?<\/b><\/p>\n

                \n
              1. After<\/span><\/li>\n
              2. Async<\/span><\/li>\n
              3. Display<\/span><\/li>\n
              4. Before<\/span><\/li>\n<\/ol>\n

                Correct Answer: 4<\/b><\/p>\n

                Explanation<\/b><\/h3>\n

                A Before Business Rule runs before the current record is saved to the database. This makes it suitable when a developer needs to modify field values before the insert or update operation completes. For example, a Before Business Rule can calculate a value or populate a field based on information in the current record. After Business Rules execute after the database operation, while Async Business Rules execute asynchronously after the transaction and are useful for work that does not need to delay the user transaction. Display Business Rules run when a record is being prepared for display. Therefore, Before timing is appropriate when changes need to be applied before database storage.<\/span><\/p>\n

                Question 388<\/b><\/h3>\n

                Which ServiceNow object is commonly used to access and manipulate form fields from a Client Script?<\/b><\/p>\n

                  \n
                1. GlideSystem<\/span><\/li>\n
                2. GlideRecord<\/span><\/li>\n
                3. GlideForm<\/span><\/li>\n
                4. GlideAggregate<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3<\/b><\/p>\n

                  Explanation<\/b><\/h3>\n

                  GlideForm<\/span>, commonly accessed through the <\/span>g_form<\/span> object, is the primary client-side API for interacting with fields and forms. It provides methods for setting field values, making fields mandatory, hiding or displaying fields, disabling controls, showing messages, and performing other form-related operations. GlideRecord is primarily a server-side API for database operations. GlideSystem, accessed through <\/span>gs<\/span>, provides server-side system functionality, while GlideAggregate is designed for database aggregation. Because Client Scripts run in the browser and need to manipulate the form interface, <\/span>g_form<\/span> is the appropriate API for these tasks.<\/span><\/p>\n

                  Question 389<\/b><\/h3>\n

                  What does the coalesce option in a Transform Map primarily determine?<\/b><\/p>\n

                    \n
                  1. Which fields can be displayed on a form<\/span><\/li>\n
                  2. How the system identifies an existing target record for update<\/span><\/li>\n
                  3. Which users can access the import set<\/span><\/li>\n
                  4. When a scheduled job runs<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 2<\/b><\/p>\n

                    Explanation<\/b><\/h3>\n

                    Coalesce fields are used during data transformation to determine whether an incoming record matches an existing record in the target table. When the values of the designated coalesce fields match an existing target record, ServiceNow can update that record instead of creating a new one. If no matching record is found, the transformation can create a new target record depending on the configuration. This mechanism is particularly useful when importing data repeatedly from an external system and avoiding unwanted duplicate records. Coalesce does not control form fields, user permissions, or scheduled execution. It primarily helps determine whether imported data should result in an insert or update.<\/span><\/p>\n

                    Question 390<\/b><\/h3>\n

                    Which API is commonly used in a Client Script to make a field mandatory?<\/b><\/p>\n

                      \n
                    1. g_form.setMandatory()<\/span><\/li>\n
                    2. gs.setMandatory()<\/span><\/li>\n
                    3. gr.setMandatory()<\/span><\/li>\n
                    4. GlideUser.setMandatory()<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1<\/b><\/p>\n

                      Explanation<\/b><\/h3>\n

                      The <\/span>g_form.setMandatory()<\/span> method is used in client-side scripting to dynamically make a form field mandatory or non-mandatory. For example, a Client Script can use <\/span>g_form.setMandatory(‘description’, true)<\/span> when a particular condition requires the user to provide a description. The <\/span>g_form<\/span> object represents the current form and provides many methods for controlling field behavior. <\/span>gs<\/span> is the GlideSystem object used mainly in server-side scripts, while GlideRecord is used for database interaction. GlideUser is not the standard API for controlling field mandatory behavior. Therefore, <\/span>g_form.setMandatory()<\/span> is the appropriate method for this requirement.<\/span><\/p>\n

                      Question 391<\/b><\/h3>\n

                      Which ServiceNow feature allows developers to package application changes so they can be moved between instances?<\/b><\/p>\n

                        \n
                      1. UI Policies<\/span><\/li>\n
                      2. Update Sets<\/span><\/li>\n
                      3. Client Scripts<\/span><\/li>\n
                      4. Reference Qualifiers<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2<\/b><\/p>\n

                        Explanation<\/b><\/h3>\n

                        Update Sets are used to capture many configuration and development changes made in a ServiceNow instance so they can be transferred to another instance. They are commonly used when moving application customizations from a development environment to a test or production environment. Changes such as Business Rules, Client Scripts, UI Policies, and other configuration records may be captured depending on the type of change and configuration. Update Sets should be reviewed and tested before being committed and moved to another environment. They are not simply a runtime feature; they provide a controlled mechanism for transporting configuration changes between instances.<\/span><\/p>\n

                        Question 392<\/b><\/h3>\n

                        Which method advances a GlideRecord object to the next record returned by a query?<\/b><\/p>\n

                          \n
                        1. move()<\/span><\/li>\n
                        2. advance()<\/span><\/li>\n
                        3. next()<\/span><\/li>\n
                        4. forward()<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3<\/b><\/p>\n

                          Explanation<\/b><\/h3>\n

                          The <\/span>next()<\/span> method is used with GlideRecord to move to the next record in the result set after a query has been executed. A common server-side pattern is to create a GlideRecord object, add query conditions, execute <\/span>query()<\/span>, and then use <\/span>while (gr.next())<\/span> to process each returned record. Each successful call to <\/span>next()<\/span> positions the GlideRecord object on another record. Methods such as <\/span>move()<\/span>, <\/span>advance()<\/span>, and <\/span>forward()<\/span> are not the standard methods used for iterating through GlideRecord query results. Understanding this pattern is fundamental for ServiceNow server-side scripting and database record processing.<\/span><\/p>\n

                          Question 393<\/b><\/h3>\n

                          Which ServiceNow feature is specifically designed to automate processes using a low-code\/no-code approach?<\/b><\/p>\n

                            \n
                          1. Flow Designer<\/span><\/li>\n
                          2. Dictionary Entries<\/span><\/li>\n
                          3. Form Layouts<\/span><\/li>\n
                          4. Database Views<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1<\/b><\/p>\n

                            Explanation<\/b><\/h3>\n

                            Flow Designer provides a low-code\/no-code environment for automating business processes in ServiceNow. Developers and administrators can create flows using triggers, actions, conditions, and other components without writing large amounts of custom JavaScript. Flow Designer can automate tasks such as updating records, sending notifications, requesting approvals, and interacting with other ServiceNow capabilities. Subflows and custom actions can also be created for reusable automation logic. Dictionary Entries define field metadata, Form Layouts control form presentation, and Database Views combine data from multiple tables for reporting or querying. Therefore, Flow Designer is the ServiceNow feature most directly associated with process automation using a low-code approach.<\/span><\/p>\n

                            Question 394<\/b><\/h3>\n

                            Which method is used to insert a new record using GlideRecord?<\/b><\/p>\n

                              \n
                            1. save()<\/span><\/li>\n
                            2. create()<\/span><\/li>\n
                            3. add()<\/span><\/li>\n
                            4. insert()<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 4<\/b><\/p>\n

                              Explanation<\/b><\/h3>\n

                              The GlideRecord <\/span>insert()<\/span> method creates a new record in the database. A developer typically initializes a GlideRecord object for the required table, assigns values using methods such as <\/span>setValue()<\/span>, and then calls <\/span>insert()<\/span>. For example, a script can set fields on a GlideRecord object and call <\/span>insert()<\/span> to save the new record. The method may return the <\/span>sys_id<\/span> of the inserted record when the operation succeeds. <\/span>update()<\/span> is instead used to save changes to an existing record. Methods such as <\/span>save()<\/span> and <\/span>create()<\/span> are not the standard GlideRecord methods used for this purpose. Thus, <\/span>insert()<\/span> is the correct choice for creating a new record.<\/span><\/p>\n

                              Question 395<\/b><\/h3>\n

                              What is the primary purpose of a Reference Qualifier?<\/b><\/p>\n

                                \n
                              1. To restrict the records available for selection in a reference field<\/span><\/li>\n
                              2. To create a new database table<\/span><\/li>\n
                              3. To execute a scheduled script<\/span><\/li>\n
                              4. To define user roles<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1<\/b><\/p>\n

                                Explanation<\/b><\/h3>\n

                                A Reference Qualifier controls which records are available for selection in a reference field. It can apply conditions so users see only relevant records when selecting a referenced record. For example, a reference field might display only active users belonging to a particular department. Reference Qualifiers can be static or dynamic depending on the requirement. They are useful for improving usability and ensuring that reference fields present appropriate choices. They do not create tables, define roles, or schedule scripts. Although a Reference Qualifier can improve data selection, it should not be confused with an ACL because ACLs are responsible for controlling access to data.<\/span><\/p>\n

                                Question 396<\/b><\/h3>\n

                                Which GlideRecord method is used to modify an existing record after changing its field values?<\/b><\/p>\n

                                  \n
                                1. update()<\/span><\/li>\n
                                2. insert()<\/span><\/li>\n
                                3. query()<\/span><\/li>\n
                                4. next()<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1<\/b><\/p>\n

                                  Explanation<\/b><\/h3>\n

                                  The GlideRecord <\/span>update()<\/span> method saves changes made to an existing record. Typically, a developer retrieves a record, changes one or more fields with methods such as <\/span>setValue()<\/span>, and then calls <\/span>update()<\/span> to persist those changes to the database. <\/span>insert()<\/span> creates a new record rather than modifying an existing one. <\/span>query()<\/span> executes a database query and does not itself save changes, while <\/span>next()<\/span> moves through query results. Developers should use update carefully, particularly when processing many records, because unnecessary database updates can affect performance. Proper query conditions and validation help ensure that only intended records are modified.<\/span><\/p>\n

                                  Question 397<\/b><\/h3>\n

                                  Which Client Script type is executed when a form is initially loaded?<\/b><\/p>\n

                                    \n
                                  1. onSubmit<\/span><\/li>\n
                                  2. onChange<\/span><\/li>\n
                                  3. onLoad<\/span><\/li>\n
                                  4. onCellEdit<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 3<\/b><\/p>\n

                                    Explanation<\/b><\/h3>\n

                                    An <\/span>onLoad<\/span> Client Script executes when a form is loaded in the user’s browser. It is commonly used to initialize form behavior based on the current record or user context. For example, an onLoad script might hide a field, display a message, or adjust a field’s behavior when the form opens. An <\/span>onChange<\/span> script runs when a specific field value changes, while <\/span>onSubmit<\/span> executes when the user attempts to submit the form. <\/span>onCellEdit<\/span> is not a standard Client Script type for normal form loading. Therefore, onLoad is the appropriate choice when behavior must occur as soon as the form is opened.<\/span><\/p>\n

                                    Question 398<\/b><\/h3>\n

                                    Which ServiceNow object provides information about the currently logged-in user in server-side scripts?<\/b><\/p>\n

                                      \n
                                    1. GlideForm<\/span><\/li>\n
                                    2. GlideUser<\/span><\/li>\n
                                    3. GlideRecord<\/span><\/li>\n
                                    4. GlideAggregate<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2<\/b><\/p>\n

                                      Explanation<\/b><\/h3>\n

                                      GlideUser<\/span> provides information and functionality related to the current user in ServiceNow scripting. It can be used to work with information such as the user’s identity, roles, groups, and other user-related properties depending on the API and context. Developers often use current-user information when implementing business logic that depends on who is performing an operation. GlideForm is primarily client-side and handles form interactions, while GlideRecord is used for database operations. GlideAggregate performs database aggregation. Understanding the distinction between these APIs helps developers select the appropriate object for a particular server-side scripting requirement.<\/span><\/p>\n

                                      Question 399<\/b><\/h3>\n

                                      What is the main purpose of a Dictionary Entry in ServiceNow?<\/b><\/p>\n

                                        \n
                                      1. To schedule integrations<\/span><\/li>\n
                                      2. To define metadata and configuration for a table field<\/span><\/li>\n
                                      3. To send email notifications<\/span><\/li>\n
                                      4. To execute Business Rules<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 2<\/b><\/p>\n

                                        Explanation<\/b><\/h3>\n

                                        A Dictionary Entry stores metadata and configuration information about a field in a ServiceNow table. It can define properties such as the field’s data type, length, default value, reference table, mandatory behavior, and other characteristics depending on the field and configuration. Dictionary Entries form an important part of ServiceNow’s data model because they describe how fields behave and are represented. They are not primarily responsible for scheduling integrations, sending notifications, or executing Business Rules. Developers and administrators may inspect Dictionary Entries when troubleshooting field behavior or understanding how a table’s fields are configured.<\/span><\/p>\n

                                        Question 400<\/b><\/h3>\n

                                        Which API is commonly used to make a server-side Script Include callable from a Client Script?<\/b><\/p>\n

                                          \n
                                        1. GlideRecord<\/span><\/li>\n
                                        2. GlideAggregate<\/span><\/li>\n
                                        3. GlideAjax<\/span><\/li>\n
                                        4. GlideDateTime<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3<\/b><\/p>\n

                                          Explanation<\/b><\/h3>\n

                                          GlideAjax<\/span> enables client-side scripts to communicate with server-side Script Includes. A Script Include must be configured appropriately, including being client callable when required, so that the client can invoke its server-side functionality. This approach is useful when a Client Script needs information that should be retrieved or calculated on the server. For example, a client script can send parameters through GlideAjax and receive a response from a Script Include. GlideRecord and GlideAggregate are primarily server-side database APIs, while GlideDateTime handles date and time operations. GlideAjax therefore provides the appropriate communication mechanism between client-side scripts and callable server-side Script Includes.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full ServiceNow CAD Exam Dumps and Practice Test Dumps.   Question 381 Which ServiceNow feature is primarily used to control which records and fields users can access? UI Policy Business Rule Access Control List (ACL) Client Script Correct Answer: 3 Explanation Access Control Lists (ACLs) are the primary security mechanism in ServiceNow for controlling […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/15630"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=15630"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/15630\/revisions"}],"predecessor-version":[{"id":15634,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/15630\/revisions\/15634"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=15630"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=15630"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=15630"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}