PEGACPSSA23V1 Pegasystems Certified Pega Senior System Architect 23 Exam Free Practice Exam Questions (2025 Updated)

Unit tests are the first line of testing when ensuring that an integration passes data as expected. They are designed to test individual parts of the code — in this case, the integration point with an external data source — to confirm that it works properly in isolation. References: Pega Platform Help - Automated Unit Testing

C:\Users\Waqas Shahid\Desktop\Mudassir\Untitled.jpg

The correct match for each error type to its description is:

Transient Errors -> These errors usually correct themselves over time.

Permanent Errors -> These errors are typically due to a configuration error or an error in the remote application logic.

To add a new minor version of an application ruleset for a phased rollout, you would lock the current version of the ruleset to prevent further changes (this is referred to as "rolling" the ruleset), and then create a new minor version. The application record should be updated to reference this new minor version of the ruleset. This ensures that the new features can be tested and gradually released to the user base without the need to create a completely new application version. References: Pega Senior System Architect documentation on versioning and release practices.

For each scenario, the appropriate mobile application solution is as follows:

"SDK application" is suitable for Globobank's scenario because they want to build a mobile app of its Pega Platform application to embed in its mobile app. The SDK would allow them to integrate Pega's capabilities within their existing mobile application environment.

"Signed application" is needed for Metrobank, which wants to distribute their mobile app on Android and iOS app stores. For an application to be accepted on these platforms, it must be properly signed with a developer certificate.

"Unsigned application" fits the scenario for Localbank, as they want to build a mobile app for a Pega Platform application but cannot distribute developer certificates to app developers. An unsigned application does not require these certificates, allowing development to proceed without them.

Based on these explanations, here are the matched solutions:

SDK application -> Globobank wants to build a mobile app of its Pega Platform application to embed in its mobile app.

Signed application -> Metrobank wants to build a mobile app for distribution on Android and iOS app stores.

Unsigned application -> Localbank wants to build a mobile app for a Pega Platform application, but developer certificates cannot be distributed to app developers.

The initial urgency is set at 20. At 5 hours, the urgency increases by 10 (total 30). At 8 hours, the urgency increases by 20 (total 50). After the deadline, the urgency increases by 20 every 2 hours, up to a limit of 5 events. By 16 hours, all 5 events have occurred, adding 100 to the urgency, leading to a total urgency of 150 (initial 20 + goal 10 + deadline 20 + passed deadline 100). References: Pega Platform Help - Service Level Agreements.

Generating report data based on several properties stored in the BLOB (Binary Large Object) can impact performance because it requires full database table scans. Using SQL query tools or activities to archive case data before purging tables can also negatively impact performance, as they may not be optimized for the Pega Platform's data structures. References: Pega Platform Help - Performance Best Practices.

The difference between using the Call and Branch methods in an activity step to invoke other activities is that Call will return to the originating activity once the called activity completes, while Branch will not return to the originating activity and will skip the remainder of it after the called activity completes. References: Pega official documentation on activity methods.

The major skim operation copies rules from the highest minor version of the current major version of a ruleset to create a new major version. In this scenario, the ruleset being skimmed is ABC:02-02-01, indicating that the current major version is 02.

Given this, the ruleset versions that would be used by the skim operation to copy rules into ABC:03-01-01 would be the highest minor versions within the major version 02.

02-01-01: This is not the highest minor version (since we have 02-02-01), so it would not be used. The answer should be "No."

01-02-01: This is from a different major version (01), so it would not be used. The answer should be "No."

02-01-05: Despite having a higher patch version, it belongs to the minor version 01 within the major version 02. Since we have a higher minor version 02, this would not be used. The answer should be "No."

Only the highest minor version from the current major version (in this case, 02-02-01) is used for the skim operation to create the new major version ABC:03-01-01. If the ruleset version 02-02-01 were listed, the correct answer would be "Yes" for that version, but as it is not listed, none of the provided ruleset versions would be used in this skim operation.

Dedicating and classifying a node for the job scheduler allows the job scheduler to run on a node that is optimized for batch processing. This ensures that resource-intensive jobs do not impact the performance of the user nodes, thus maintaining peak performance at all hours. References: Pega Platform Help - Job Schedulers.

To include access groups in your Product rule, you can add the access groups to the application record, which incorporates all the necessary rules for the application. Additionally, you can add the access group directly to the Product rule in the 'Individual instances to include' section, which allows you to specify individual rules and data instances that the Product rule should include. References: Pega Platform Help - Creating a Product rule.

To fulfill orders received during the peak season in December and process the orders in batches multiple times a day, you would create a queue processor that can process orders received by the company. Queue processors are designed to handle asynchronous, high-volume processing, which is suitable for the described use case. References: Pega official documentation on queue processors.

Graphical user interface Description automatically generated

To match the security solutions to their appropriate use cases:

"Access of Role to Object" is typically used to specify what actions a particular role can perform on instances of a class. It would be appropriate for a use case where "Dealers can modify evaluations" since this is an action that a specific role (dealers) would be allowed to perform.

"Access Control Policy" allows defining rules that enforce property and case access restrictions based on the user role and other conditions. It would be appropriate for a use case where "Customers can only view their own credit report" since this would be a restriction based on user-specific data.

"Access Deny" is used to explicitly deny access to a rule or data instance. It fits the use case where "Dealers cannot run reports" because it is a restriction that prevents a specific action (running reports) for a specific role (dealers).

"Access when" is a rule that defines conditions for whether certain access is allowed. It would be used in the scenario where "Dealers cannot modify orders in the Fulfillment stage" since this is a conditional restriction based on the stage of the process.

Based on these explanations, here is the matched list:

Access when -> Dealers cannot modify orders in the Fulfillment stage.

Access Control Policy -> Customers can only view their own credit report.

Access Deny -> Dealers cannot run reports.

Access of Role to Object -> Dealers can modify evaluations.

To enable property-level encryption for sensitive data such as SSN and Account Number, you create an Access Control Policy of type PropertyEncrypt. This policy specifies which properties should be encrypted and how the encryption should be applied. References: Pega Platform Help - Access Control Policies.

To allow both doctors and nurses to modify cases while complying with the identified security requirements, the best approach is to create a single access role for both doctors and nurses (C) and set the modify action to 5. This configuration grants both user groups the necessary permissions to modify cases throughout the case life cycle. By using a single access role with a high level of access for modifications, the application simplifies role management while ensuring that both doctors and nurses can perform their duties effectively, without compromising the security and integrity of patient cases.References: Pega Community documentation on Access Role to Object and case management best practices.

Pega best practices recommend keeping activities short to enhance maintainability and readability. Custom Java steps should be limited to reduce complexity and potential errors. Activities should also be limited in general, with preference given to other rule types that are more declarative and less procedural, like data transforms, to improve application performance and maintainability. References: Pega SSA course materials on activity best practices.

In Pega's ruleset hierarchy, a ruleset can reference rules in its own ruleset as well as in any prerequisites (and their prerequisites, recursively). Since MyCo lists MyCoInt and Customer as its prerequisites and MyCoInt, in turn, lists Pega-ProcessCommander (which is not relevant here), MyCo can reference rules in both Homelns and HomelnsInt. However, since only Homelns is explicitly mentioned in the options, the correct answer is that MyCo can reference rules in Homelns. References: Pega SSA course materials on ruleset hierarchy and ruleset validation.

The function of class mapping for reports is to retrieve data from an associated database table. Class mapping determines which table data is pulled from when running a report, ensuring that the report includes the appropriate data based on the class structure. References: Pega official documentation on class mapping and reporting.

An edit validate rule is used to ensure that data is entered in a specific format. For membership numbers that need to match a particular pattern (M-######-0#), an edit validate rule would be the appropriate mechanism to enforce this format upon entry. References: Pega Platform Help - Edit Validate.