PEGACPRSA22V1 Questions and Answers

In Pega Platform, data objects used for integration with robot activities (whether attended or unattended) must be scalar properties — that is, single-value fields such as Text, Decimal, Date, Boolean, etc. Scalar properties represent discrete, individual data elements that can be directly serialized and passed between Pega Platform and Pega Robot Studio automations.

According to the Pega Robotics System Design and Implementation Guide, section “Data Mapping Between Robot Activities and Pega Case Data”:

“Robot activities can import and export data values only for scalar properties.

Scalar properties represent single data items, while complex or list structures (such as Page Lists or Page Groups) cannot be directly transferred.

Complex data types must be iterated or flattened before being used in a robot activity.”

In the image provided, the data model includes several scalar properties (e.g., AmountOfTransactionToDispute, pyID, TransactionAmount) and one list-type property — Transactions, defined as a List of records.

Detailed Reasoning:

A. AmountOfTransactionToDispute — Scalar property of type Decimal. Can be imported/exported by robot activities.

B. pyID — Scalar property of type Text (single line). Can be used in robot activity data mapping.

C. Transactions — Non-scalar property defined as a List of records.

This represents a collection (a Page List) rather than a single field.

Robot activities cannot directly import or export this type; it must be handled via iteration or transformation before use.

D. TransactionAmount — Scalar property of type Decimal. Can be imported/exported normally.

Therefore, Transactions is the only non-scalar property in the model and cannot be directly imported or exported to or from a robot activity.

Final Correct Answer: C. Transactions

 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

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.

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

Reference http://help.openspan.com/80/Platform_Configuration/RuntimeConfigXML.htm

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

In Pega Robot Studio, the Start My Day (SMD) functionality allows a user to define and launch all required applications at once when starting work. The configuration of these applications is performed in the Manage Applications window, where each application can be individually enabled or disabled for automatic startup.

According to the Pega Robotics System Design and Implementation Guide, in the section “Start My Day Configuration and Manage Applications”, the documentation specifies the following:

“Applications configured for Start My Day will launch automatically when the Start My Day feature is invoked.

The Manage Applications dialog lists all project applications and determines which ones are launched using the ‘Enabled’ checkbox.

Only applications marked as enabled will be started when the user initiates Start My Day. Applications that are listed but not enabled remain closed.”

The screenshot in the question shows the following configuration under the Manage Applications window:

Application

Enabled

Type

Path

Pega Finance

Yes

Adapter

C:\Users\Pega Training\Desktop\BankerInsight...

BankerInsight

Yes

Adapter

C:\Program Files (x86)\CRM Setup\CRM.exe

CRM

No

Exe

C:\Program Files (x86)\CRM Setup\CRM.exe

Notepad

Yes

Exe

C:\Windows\notepad.exe

From this configuration, the Enabled column indicates that the following applications will start automatically when Start My Day is triggered:

Pega Finance

BankerInsight

Notepad

The CRM application is not enabled and therefore will not launch.

Option Analysis:

Option A (Pega Finance, Notepad, BankerInsight): Correct, as these are the enabled applications.

Option B (CRM, BankerInsight): Incorrect, because CRM is not enabled.

Option C (CRM, Notepad, BankerInsight): Incorrect, because CRM is not enabled.

Option D (Pega Finance, CRM, Notepad, BankerInsight): Incorrect, because CRM is not enabled.

Therefore, the correct answer is A. Pega Finance, Notepad, BankerInsight.

In Pega Robot Studio, the Project Explorer provides a structured view of all the components that belong to a project. These include applications, automations, and any methods (application-level procedures) associated with each application. The hierarchy in the Project Explorer reflects the relationship and scope of these components.

According to the Pega Robotics System Design and Implementation Guide (Project Structure and Scoping Rules section):

“Each application added to a Pega Robotics project appears under the ‘Globals’ node.

Automations are listed as separate automation objects under the application node.

Application methods such as Login or CustomerSearch are defined directly under the application to which they belong, following the hierarchy:

Globals → ApplicationName → Automations → Application Methods.”

Based on this structure:

The Globals node appears at the top.

The BankerInsight application appears under Globals.

Within BankerInsight, the two automations — AddCustomer and RemoveCustomer — are listed.

Under the same application node, the application methods CustomerSearch and Login also appear, showing they belong specifically to the BankerInsight scope.

Option C correctly represents this hierarchy because it shows:

Globals at the root.

BankerInsight as the single application node.

Under BankerInsight, both automations (AddCustomer, RemoveCustomer) and the application methods (CustomerSearch, Login) appear in sequence.

Other options show misplaced or missing elements:

Option A: Incorrect — does not display both automations and methods under the same hierarchy.

Option B: Incorrect — application methods are misplaced outside of the BankerInsight node.

Option D: Incorrect — application methods appear incorrectly scoped under separate folders.

Therefore, Option C aligns perfectly with the standard Pega Robotics Project Explorer hierarchy for the given configuration.

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.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

The Lookup Table is a global component in Pega Robot Studio that can be accessed from multiple automations within a project.

To use its methods—such as ImportDelimitedFile, FindRecord, or AddRecord—you must drag the lookup table instance from the Globals section to the automation surface.

According to the Pega Robotics System Design and Implementation Guide, section “Using Lookup Tables in Automations”:

“Lookup tables are global components that store data used across automations.

To call lookup table methods, drag the table from the Globals section of the Palette to the automation design surface.

The Select Action dialog box will open, allowing you to filter and select from available methods such as ImportDelimitedFile, FindRecord, and ClearTable.”

Detailed Reasoning:

A. Select the ImportDelimitedFile method in a design form... – Incorrect. The lookup table is not part of the UI form.

B. Drag the lookup table from the Locals section... – Incorrect. Lookup tables exist under Globals, not Locals.

C. Open the Globals tab and filter... – Incorrect. You must drag the component onto the automation surface to expose its methods.

D. Drag the lookup table from the Globals section... – Correct. This exposes the ImportDelimitedFile method through the Select Action dialog.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

The PegaRuntimeConfig.xml file contains configuration settings that control how users interact with Pega Robot Runtime on their desktops.

These settings define parameters such as:

Robot tray icon visibility

Notification preferences

Runtime startup behavior

Access permissions for attended automation

According to the Pega Robotics System Design and Implementation Guide, section “Runtime Configuration Settings”:

“The PegaRuntimeConfig.xml file defines user interaction settings and behavior of Pega Robot Runtime on end-user desktops.

It specifies configurations related to user access, tray icon visibility, notification pop-ups, and desktop automation permissions.”

Detailed Reasoning:

A. PegaConfig.xml – Not a valid configuration file in Pega Robotics.

B. CommonConfig.xml – Used for shared system-wide connectivity and Robot Manager settings.

C. PegaStudioConfig.xml – Stores configuration data for Pega Robot Studio (developer-specific).

D. PegaRuntimeConfig.xml – Correct. Defines desktop-level user interaction and Runtime behavior.

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.

Comprehensive and Detailed Explanation From Pega Robotics System Exact Extract:

An application project item in Pega Robot Studio represents an integration layer between the automation project and an external application (Windows, Web, or Text). Each project item defines how to launch, attach, and control the target application.

According to the Pega Robotics System Design and Implementation Guide, in the section “Application Project Items Overview”, it states:

“An application project item defines the interaction between a robotic solution and an external application.

It provides properties, methods, and events that allow the automation to start, monitor, and control the target application.

Pega Robot Studio supports application project items for Windows, Web, and Text adapters, enabling integration with all major enterprise application types.”

Detailed Reasoning:

Option A is correct because application project items are the mechanism by which Pega Robotics integrates with Windows, Web, and Text applications on the client machine.

Option E is correct because each application project item exposes properties, methods, and events that control application behavior (for example, launch, close, monitor, or read UI data).

Option B is incorrect — Pega Platform integration is handled through Robot Manager or Runtime API, not through application project items.

Option C is incorrect — Application items do not use REST or JavaScript; these are specific to web connectors.

Option D is incorrect — Deployment orchestration and robot monitoring are performed by Robot Manager, not by an application project item.

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