Pegasystems PEGACPRSA22V1 Certified Pega Robotics System Architect 22 Exam Practice Test

To diagnose a failure occurring on a link from a control’s Properties call to a String service’s Equals(), you must place breakpoints on the event links immediately before the failing link so you can inspect the values being passed (for example, the account number) and confirm whether a null is being propagated.

Pega Robot Studio debugging guidance:

“Breakpoints can be set on event links to pause execution at specific steps in an automation. During a paused state, developers can inspect the values on connected data ports to determine whether null or unexpected values are being passed to the next step.”

“Place breakpoints upstream of the failing event to verify the value retrieved from a control (for example, via a Properties call) before it is sent into a service method (such as Equals).”

Option A shows a breakpoint on the event path feeding the Properties block and another just before the segment that calls Equals(). This allows you to stop exactly where the input to Equals(string2) would be evaluated and verify whether it is null.

Option C also places a breakpoint directly on the event link leading into the Properties/Equals segment, which is the correct spot to pause and inspect the data value before the comparison occurs.

Options B, D, and E place breakpoints either too early (not reaching the Properties/Equals path yet) or on unrelated branches, which won’t reliably expose the null value being passed into IStringService.Equals().

Pega Robotics Studio – Automation Design Concepts (Entry/Exit Points & Parameters)

“An automation can expose multiple exit points (for example, Success and Failure) and can define output parameters that return values to the caller. When the automation completes, the appropriate exit point is raised and the output parameters are made available to the caller.”

Pega Robotics Studio – Calling Automations (Run and Parameter Mapping)

“When one automation calls another, the called automation appears as a component with input parameters, output parameters, and exit points. The caller wires the Success/Failure exits to the next steps and maps output parameters (for example, result, errCode) to downstream logic.”

Why Option C is correct:

The UpdateCustomerDetails block in Option C clearly shows two exit points — Success and Failure — and two output parameters — result and errCode — on the subautomation.

The wiring demonstrates a typical pattern:

On Success, the flow proceeds to a success path with result available.

On Failure, the flow proceeds to a failure path with errCode available (the extra, unused result pin on the failure jump is permissible but not required).

This matches the specification precisely: two exits (Success/Failure) and two outputs (result, errCode).

Why the other options are not correct:

Option A: Shows errCode but does not expose result clearly as an output to the success path.

Option B: The component does not display errCode as an output parameter of the subautomation.

Option D: Emphasizes an additional boolean/conditional output and maps result on the failure path, which does not reflect the stated definition of the subautomation outputs.

Document Sources (Exact Extracts Reference):

Pega Robotics Studio User Guide — Automation Design Concepts: Entry/Exit Points and Parameters.

Pega Robotics Studio User Guide — Calling Automations and Mapping Inputs/Outputs.

Pega Robotics System Certification Study Material — Subautomation design patterns (Success/Failure with output parameters).

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

When working with UI controls such as combo boxes in a custom user interface (Windows form or User Interaction form), you can expose their methods and events by dragging the control from the Palette or Object Explorer to the automation design surface.

According to the Pega Robotics System Design and Implementation Guide, section “Accessing Control Methods and Properties in Automations”:

“To access a control’s methods or events in an automation, drag the control (such as a combo box or text box) from the Object Explorer or Palette to the automation surface.

The Select Action dialog box appears, allowing you to filter and choose the specific method or event (for example, AddItem, RemoveItem, or Clear).”

Detailed Reasoning:

A. Drag the combo box to the automation surface... – Correct. This opens the Select Action dialog, exposing all available methods and events for that control.

B. Open the Globals tab... – Incorrect. The combo box methods are not global; they belong to a specific UI form.

C. Select the combo box in a design form... – Incorrect. This action edits UI layout, not automation logic.

D. Select the combo box in the Palette tab... – Incorrect. The properties grid shows attributes, not callable methods.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

In Pega Robot Studio, toast notifications are used to display short, non-blocking messages to users during runtime. These notifications are highly customizable and can be globally managed to maintain consistent branding across an enterprise automation project.

According to the Pega Robotics System Design and Implementation Guide (UI Messaging and Toast Notifications section):

“Toast notifications can be added to the Globals tab of a project to maintain consistent visual and behavioral configuration throughout the solution.

The notification element placed in Globals allows setting properties such as title, duration, color, font, and position that are shared by all automations calling the Show() method.

Automations reference the global toast notification by invoking its Show method from the Globals section of the Palette.”

This means that:

The best practice for ensuring uniform design and branding (consistent colors, layout, font, and position) for toast messages is to define one global toast notification in the Globals tab.

Once the global toast notification is configured, all automations that require displaying toast messages will simply call its Show() method, inheriting the standardized display settings.

Option Analysis:

A. Incorrect — Adjusting the Utilities section does not define reusable toast notifications.

B. Incorrect — The project properties do not include toast formatting controls.

C. Incorrect — Creating an automation to set these dynamically would not enforce consistent styling across all notifications and is not recommended.

D. Correct — Placing a toast notification in the Globals tab allows defining display parameters once and reusing them via the Show() method in automations, ensuring global consistency in branding and formatting.

Therefore, the correct and Pega-recommended approach is Option D.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

The PegaRuntimeConfig.xml file defines environment-specific configurations for the Pega Robot Runtime application.

To automatically launch a robotic solution (.pega file) when Runtime starts, you must configure the Startup Project path inside this XML file.

According to the Pega Robotics System Design and Implementation Guide, section “Configuring Pega Robot Runtime for Automatic Project Launch”:

“To make Pega Robot Runtime automatically load and execute a robotic solution at startup, modify the PegaRuntimeConfig.xml file.

Within this file, specify the absolute path of the solution’s .pega file under the element.

When Pega Robot Runtime is launched, it reads this configuration and automatically opens the specified project.”

Detailed Reasoning:

A. PegaStudioConfig.xml – Incorrect. This file is specific to Robot Studio, not Runtime.

B. PegaRuntimeConfig.xml – Correct. The StartupProject element in this file defines which project (.pega file) to load automatically when Runtime starts.

C. CommonConfig.xml – Incorrect. Used for shared server and connection configurations, not for startup settings.

D. DisputeTransaction.pega – Incorrect. This file is a project package and does not contain configuration data.

Reference

 Tools

 Folders

 Files

Before deploying automations to a production environment, it’s essential to update configuration files such as PegaRuntimeConfig.xml, CommonConfig.xml, and CredentialManagerConfig.xml. These files define how the robot connects to Pega Robot Manager, how the runtime behaves, and how credentials are managed for Assisted Sign-On.

In Pega Robot Studio, these files are accessed through the Debug menu path that navigates through several levels — starting from Tools, then Folders, and finally Files.

From the Pega Robotics System Design and Implementation Guide, section “Accessing and Editing Configuration Files for Deployment”:

“Configuration files used by the Pega Robot Runtime environment can be accessed within Robot Studio through the Debug menu.

The access path is Debug → Tools → Folders → Files.

This navigation path opens the directory containing essential configuration files such as PegaRuntimeConfig.xml, CommonConfig.xml, and CredentialManagerConfig.xml, which can be modified to point to the correct environment (test, staging, or production).”

Detailed Step Explanation:

Step 1: Tools

The Tools section under the Debug menu provides access to the environment utilities used for configuration and diagnostics.

Step 2: Folders

Under Tools, select Folders to navigate to the configuration folder where Robot Studio and Runtime files are stored.

Step 3: Files

Within Folders, click Files to open and view all editable XML/JSON configuration files required for environment updates (e.g., PegaRuntimeConfig.xml, CommonConfig.xml, CredentialManagerConfig.xml).

By following this sequence, developers can easily access and update environment settings before packaging the deployment.

Final Correct Sequence:

Tools

Folders

Files

In Pega Robot Studio, an environment override allows developers to configure multiple deployment environments (such as test, staging, and production) using a single project. This helps you avoid creating separate projects for each environment and ensures consistent automation logic while dynamically switching between environment-specific settings at runtime.

According to the Pega Robotics System Design and Implementation Guide, section “Managing Environment Overrides and Multi-Environment Deployments”:

“Environment overrides provide a mechanism to define environment-specific configuration values for applications within a project.

For example, the same automation logic can be used for both test and production systems by creating separate environment override files — one for the test environment and one for the production environment — each specifying unique paths, credentials, or URLs for the corresponding system.”

Detailed Reasoning:

The HR system has different access points for test and production, which typically means different URLs or executable paths.

The automation logic (how the robot interacts with the HR application) remains identical; only the connection configuration changes.

Therefore, instead of creating multiple applications or modifying logic, you configure two environment override files — one for production and one for test — each defining environment-specific details such as:

Application path (for Windows adapters)

StartPage URL (for web adapters)

Credentials or runtime parameters

This allows a single automation project to adapt dynamically based on which environment override is active during deployment or testing.

Option Analysis:

A. Incorrect — A single override cannot contain two sets of environment details; each override corresponds to one environment.

B. Incorrect — Creating two applications increases complexity and redundancy; both would duplicate the same logic.

C. Incorrect — Adding both separate applications and overrides is unnecessary; overrides alone are sufficient for environment flexibility.

D. Correct — Two environment overrides (one for production, one for test) allow the same project and automation logic to function properly across both environments.

Therefore, the correct answer is D. Create two environment overrides for the HR System project: one override for production, and one for test.

Let’s carefully analyze the automation step by step as shown in the image.

Given property values:

Double1 = 2

Double2 = 6

Double3 = 3

Step-by-Step Execution Logic

First Expression:

a + b / c = result

Substitute values:

→

So, result = 4

Second Expression:

a < 3 = result

Substitute a = 2

→ → True

So, result = True

Third Expression:

a + "result" = result

Here, the operator "+" is used for string concatenation.

The variable a is treated as a Boolean (from the previous step), and concatenated with the string "result".

Since a (previous Boolean output) = True, the expression becomes:

"True" + "result" = "Trueresult"

So, result = "Trueresult"

Final Assignment:The final value of result (which is "Trueresult") is assigned to the variable outputString.

Therefore,

outputString = "Trueresult"

Correct Answer:

B. Trueresult

Comprehensive Extract from Pega Robotics System Documentation:

According to the Pega Robotics System Design and Implementation Guide, section “Arithmetic and Logical Expression Evaluation in Automations”:

“Expressions in automations are evaluated left to right following operator precedence.

When concatenating data of different types, Pega Robot Studio converts numeric and Boolean values to strings before concatenation.

The result of a string concatenation between a Boolean value and a literal string results in a merged string output.”

Detailed Reasoning Recap:

Step

Expression

Evaluation

Result

1

2 + 6 / 3

4

4

2

2 < 3

True

True

3

True + "result"

"Trueresult"

"Trueresult"

Final Answer: B. Trueresult

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

The Label/Jump To functionality in Pega Robot Studio is used to improve automation organization and logical control flow.

Labels act as named anchor points within a single automation, and Jump To links can redirect the execution flow to these labeled points.

According to the Pega Robotics System Design and Implementation Guide, section “Using Labels and Jump To Blocks in Automations”:

“The Label/Jump To functionality enables structured flow management within a single automation.

Labels define points in the automation to which the execution flow can jump.

Jump To blocks redirect execution to a corresponding label, allowing developers to organize complex automations into manageable sections.

This feature is particularly useful for debugging, error handling, and implementing multiple exit paths within a single automation.”

Detailed Reasoning:

A. It allows you to pass variables to different parts or workflows of the same automation.

Incorrect. The Label/Jump To mechanism changes the flow of execution; it does not pass or transfer variable data between workflows.

B. It allows you to keep automations organized and aids in debugging.

Correct. Labels and Jump To blocks make complex automations more readable and structured by dividing logic into sections. This improves debugging and maintenance.

C. It allows you to pass variables to different automations of the same project.

Incorrect. Variables between automations are passed using parameters (inputs/outputs), not Label/Jump To blocks.

D. It allows you to have multiple Exit points in an automation.

Correct. By strategically placing labels and jumps, you can create multiple exit conditions or termination points within a single automation, improving control flow.

E. It allows you to connect with other automations in the project.

Incorrect. Connections to other automations are made through automation calls, not Label/Jump To links.

Final Correct Answer: B, D

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

According to the Pega Robotic Automation Asset Management and Studio Guide:

“Robotic automation assets are reusable components—such as automations, global scripts, adapters, and configuration items—that are shared across multiple robotic projects. Assets enable organizations to maintain consistency and streamline project development.”

The documentation elaborates:

• “Assets streamline the development process across the enterprise by reducing duplication of work.”

• “Shared automation assets ensure consistency of development, coding standards, and project structure across teams and projects.”

• “Assets are version-controlled and centrally stored in the Pega Robot Manager or Deployment Portal for reuse.”

It also clarifies that assets are not customizable after download because they are version-controlled and used as read-only components, ensuring enterprise-wide standardization.

Therefore:

Option A — True (Assets streamline enterprise development).

Option C — True (Assets ensure consistency across projects).

Option B — Incorrect (Assets are not designed for post-download modification).

Option D — Incorrect (Assets reduce development time, not increase it).

References (Exact Extract Source):

Pega Robotics Studio User Guide – Robotic Automation Assets and Asset Management

Pega Academy – Robotics System Architect Certification Course (Asset Sharing and Reusability)

Pega Robot Manager – Asset Lifecycle and Governance Overview

Final Verified Answer: A, C

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

When building robotic automations intended for integration with Pega Platform (through Robotic Desktop Automation (RDA) or Robotic Process Automation (RPA)), Pega Systems outlines a set of best practices to ensure reliable execution, data consistency, and seamless communication between the automation and Pega case workflows.

According to the Pega Robotics System Design and Implementation Guide, in the section “Developing Robot Activities for Pega Integration”, the following recommendations are provided:

“When developing automations intended for execution by Pega applications, adhere to the following guidelines:

Always return a valid completion status from the automation to indicate success or failure to the calling Pega activity.

Ensure that the data exchanged between Pega Platform and the automation matches in both type and format to prevent runtime errors or data transformation issues.

The activity name in Pega Platform (as specified in the robotic automation name field) must exactly match the name defined in the Robot Activity component in Robot Studio to establish a valid invocation link.”

Detailed Reasoning:

A. Set valid completion status.

Correct. Each automation that is invoked from Pega must return a valid completion status (e.g., Success, Fail, Completed, Error). This status is sent back through the Robot Activity response data transform.

This ensures that the Pega case or data page correctly interprets the automation’s result and can take subsequent actions (e.g., proceed, retry, or raise an exception).

D. Ensure data formats agree between the automation and the Pega application.

Correct. The data types and structure between Pega and the robotic automation must align (for example, string-to-string, integer-to-integer, JSON format consistency).

Mismatched or unstructured data results in serialization errors when passing data through the RDA bridge.

E. Match the Pega automation identifier with the robot activity component name.

Correct. The Robotic Automation Name specified in the Pega data page or case configuration (e.g., FETCH_SCORE) must exactly match the ActivityName property defined in the Robot Studio’s Robot Activity component.

This linkage ensures that the correct automation is triggered when the case executes the RDA call.

Incorrect Options:

B. Design an automation to complete multiple tasks.

Not recommended. Pega advises building modular automations, where each automation performs a single defined task to simplify debugging and improve reuse.

C. Use an unlimited number of transferable data items.

Not recommended. The number of data items passed between Pega and Robotics should be limited to those necessary for the task, as excessive data transfers can degrade performance.

F. Run automations synchronously.

Not required. RDA automations typically run asynchronously, returning results through callback mechanisms to avoid blocking the user interface.

Therefore, the three recommended developer considerations are:

A. Set valid completion status

D. Ensure data formats agree between the automation and the Pega application

E. Match the Pega automation identifier with the robot activity component name

(Correct Order):

Hover your pointer over the control.

Click the Gear icon.

Set the Action to Set Text.

In the Value list, select Create New.

Set the Value source to Input parameter.

In the Name field, enter the name of the input parameter.

Click Submit to save the input parameter.

Click Save to save the step.

Targeted Step Creation is a Pega Robot Studio feature used to record automation steps directly by interacting with an interrogated control (for example, typing into a textbox). When the automation being recorded needs to receive data from another automation, an input parameter is configured as the value source for the recorded step.

According to the Pega Robotics System Design and Implementation Guide, section “Recording Steps and Configuring Input Parameters”:

“When recording a targeted step for an input control:

Hover over the target control and select the Gear icon to open the recording configuration.

Choose the appropriate action (for example, Set Text for text boxes).

Create a new value reference and select Input parameter as the value source.

Assign a name to the input parameter that will be passed from the calling automation.

Submit and save the step to finalize the recording.”

Detailed Step Reasoning:

Hover your pointer over the control.

This initializes the control recognition in targeted step creation mode.

Click the Gear icon.

Opens the step configuration dialog for the selected control.

Set the Action to Set Text.

Defines the intended action for the control (entering text).

In the Value list, select Create New.

Creates a new value definition to assign data to the control.

Set the Value source to Input parameter.

Ensures that the value for the text input will come from an external automation that invokes this one.

In the Name field, enter the name of the input parameter.

Defines the name of the input variable so that it can be referenced when calling this automation.

Click Submit to save the input parameter.

Confirms and stores the parameter definition.

Click Save to save the step.

Finalizes the recorded step in the automation sequence.

Final Ordered Steps:

Hover your pointer over the control.

Click the Gear icon.

Set the Action to Set Text.

In the Value list, select Create New.

Set the Value source to Input parameter.

In the Name field, enter the name of the input parameter.

Click Submit to save the input parameter.

Click Save to save the step.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

During interrogation of web applications, developers often encounter dynamic or hidden controls — such as drop-down menus or hover-triggered lists — that do not immediately appear on the page.

To successfully interrogate these elements, Pega Robot Studio provides two essential tools:

The Delay option on the Interrogation Form, which allows the developer time to trigger the hidden control before capture.

The Select Element option, which enables precise selection of an element directly from the DOM, even if it is not immediately visible.

According to the Pega Robotics System Design and Implementation Guide, section “Interrogating Dynamic and Hidden Web Controls”:

“When interrogating hidden or dynamically rendered controls:

Use the Delay option on the Interrogation Form to give yourself time to hover over or activate a hidden control before Robot Studio attempts to capture it.

Use the Select Element option to manually highlight and select a control from the web application’s DOM, even when it is displayed only after an interaction such as mouse hover.These methods are particularly effective for controls that expand or render asynchronously, such as drop-down menus or tooltip-triggered elements.”

Detailed Step Reasoning:

C. Use the Delay option on the Interrogation Form.

Correct.

The Delay setting pauses the interrogation process for a specified number of seconds, allowing you to hover over the hidden element (e.g., AddressType menu) and make it visible before capture.

Once the menu appears, Pega Robot Studio can detect and interrogate it.

D. On the Interrogation Form, select Select Element.

Correct.

The Select Element tool allows manual selection of an element directly from the web page’s HTML DOM structure.

This is especially useful for hidden or dynamically rendered elements like the AddressType dropdown that may not be visible until hovered over.

Incorrect Options Explained:

A. In the Interrogation Form dialog box, select HTML Table Editor.

Incorrect.

The HTML Table Editor is used to inspect and modify HTML table-based controls (grid or table structures), not dynamic menus.

B. On the Web Controls tab, select the page, and then click List Web Controls.

Incorrect.

The List Web Controls option lists already recognized controls in the DOM but cannot reveal or capture hidden dynamic elements.

E. On the Application tab, click the Virtual Controls tab.

Incorrect.

Virtual Controls are used for defining custom controls when the default adapter cannot identify one, not for capturing hidden menu elements.

Final Correct Answer:

C. Use the Delay option on the Interrogation Form.

D. On the Interrogation Form, select Select Element.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

Unattended automations, also referred to as Robotic Process Automations (RPA), are automations that execute without human intervention. These automations operate on robotic work queues managed by Pega Robot Manager, performing background tasks automatically.

According to the Pega Robotics System Design and Implementation Guide, section “Unattended Automations (RPA) — Execution Model and Characteristics”:

“Unattended automations execute robotic tasks in a fully automated manner without user interaction.

They retrieve assignments from robotic work queues in Pega Robot Manager, perform the specified automation tasks, and return results and case updates to Pega Platform.

These automations help streamline business workflows by automating repetitive tasks in back-end processes.”

Detailed Reasoning:

A. They retrieve the next case assignment in a robotic work queue.

Correct. RPA bots work from the Robot Queue (Pega’s work queue) where cases are assigned for unattended processing.

B. They execute a fully automated task.

Correct. Unattended automations perform end-to-end automation without requiring human assistance.

C. They can streamline and automate portions of your case management workflow.

Correct. These automations integrate with Pega Platform cases, performing sub-tasks or full case resolutions automatically to improve efficiency.

D. They run during pre-processing to obtain information to display on a form.

Incorrect. That behavior describes attended automations (RDA) that assist end users in real time.

E. They complete the automated tasks based on user input.

Incorrect. Unattended automations operate without any user input; attended ones are triggered by user actions.

In Pega Robot Studio, when an automation (especially one invoked as a robot activity by Pega Platform) finishes execution, it must return a Completion Status. This status helps the Pega Platform determine the outcome of the automation and decide whether to continue the workflow, retry, or handle an exception.

According to the Pega Robotics System Design and Implementation Guide, section “Robot Activity Completion Status and Workflow Integration”:

“Each robotic activity returns a Completion Status to the Pega Platform after execution.

The completion status communicates the final outcome of the automation’s operation, indicating whether it successfully completed, encountered errors, or produced invalid data.

The most common statuses used are:

Complete: The automation ran successfully, and data passed all validation checks.

DidNotComplete: The automation ran to completion, but business validation failed or data was deemed invalid.

CompletedWithErrors: The automation could not complete execution due to a system or process error.”

Detailed Reasoning:

Complete

Indicates that the robotic automation successfully executed and the resulting data passed all validation checks within Pega.

This allows the Pega case flow to continue normally.

Correct Match: “If data passes business validation, the processing flow continues.”

CompletedWithErrors

Used when the automation fails to complete due to a technical issue or system error (for example, an application did not load or a connector failed).

This causes the flow to route as a failure in Pega.

Correct Match: “If the automation fails to complete, it routes as a failure.”

DidNotComplete

Indicates that the automation successfully executed technically but failed business validation, such as incorrect data, missing inputs, or business rule mismatches.

Correct Match: “If the automation completes processing, but the data fails business validation.”

Final Correct Matching Order:

Completion Status

Automation Description

Complete

If data passes business validation, the processing flow continues.

CompletedWithErrors

If the automation fails to complete, it routes as a failure.

DidNotComplete

If the automation completes processing, but the data fails business validation.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

In Pega Robot Studio, when interrogating Java applications, sometimes a child process is created separately from the main application process. In such cases, controls in the child process cannot be detected unless the adapter is configured to attach to child processes as well.

According to the Pega Robotics System Design and Implementation Guide, in the section “Java Application Integration and Child Processes”:

“For Java applications that spawn additional processes, set the HookChildProcesses property of the adapter to True.

This enables the adapter to attach to both the main process and any child processes created by the parent application, allowing interrogation and automation of controls within those secondary windows.”

Detailed Reasoning:

HookChildProcesses ensures that when a Java application spawns a new process (such as a popup or a grid), Pega Robotics attaches to and monitors that process.

Without enabling this property, the adapter would only recognize the primary Java process, leaving controls in secondary processes unrecognized.

Option Analysis:

A. HookChildProcesses: Correct. Allows interrogation of child processes.

B. EnableMatchInProcess: Incorrect. Used for controlling object matching within the same process context.

C. TargetPath: Incorrect. Defines executable location for adapters.

D. IgnoreMainBrowser: Incorrect. Related to web adapters, not Java applications.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

In Pega Robot Studio, the Increase Deployment Version property in the project settings is used to automatically update the deployment version number each time the project is deployed.

This ensures version consistency across builds and deployments in environments managed by Pega Robot Manager.

According to the Pega Robotics System Design and Implementation Guide, section “Project Deployment and Version Control”:

“The Increase Deployment Version property, when set to True, automatically increments the project’s deployment version number during the deployment process.

This feature helps maintain proper version tracking and eliminates the need for manual version adjustments before deployment.”

Detailed Reasoning:

A. Environment Overrides – Used to specify environment-specific configuration overrides, not for version control.

B. Version field – Displays the current version number but does not auto-increment it.

C. Description field – Used for textual descriptions of the project only.

D. Increase Deployment Version – Correct. When set to True, it automatically adjusts the version numbering upon deployment.