PEGACPLSA88V1 Sample Questions Answers

To configure a data page that accepts either a postal code or a city name as a parameter and calls the appropriate REST connector:

Use separate REST connectors for each parameter type and a when rule to determine which connector to use based on the input parameter.

Alternatively, use an activity to evaluate the parameter and dynamically select the appropriate REST connector at runtime.

To design a reporting strategy that displays the number of cases by status at the end of each month for a 12-month period, follow these steps:

Configure an Agent: Set up an agent to run at the end of each month to capture the status of all cases.

Record Data: The agent records the case statuses in a separate table specifically created for this purpose.

Reporting: Generate reports based on the data stored in this table to provide an accurate month-end snapshot of case statuses.

References:

Configuring agents in Pega

Advanced Mode Configuration:

Configure the agent to run in Advanced mode to gain more control over its execution.

Periodic Pattern:

Set the agent to run with a Periodic pattern, scheduling it to execute daily at midnight.

Ensure the agent checks for customer birthdays and sends out emails accordingly.

When designing a solution that requires customer data from multiple external systems and ensuring it is as current as possible, consider the following:

Parallel Data Loading: Use the Load-Data Page and Connect-Wait methods to load the data in parallel. This approach improves performance by reducing the time taken to gather the required customer data since multiple data sources are queried simultaneously.

System of Record (SOR) Pattern: Employ the System of Record (SOR) data access pattern to fetch the most current customer data from the external systems directly. This ensures that the data used is up-to-date and reflects the latest information available from the source systems.

References: Pega Platform documentation on data pages, Connect-Wait methods, and data access patterns.

 Embedded List with Declare Index:

Both Case Types A and B possess an embedded list of line items. Using a Declare Index against each embedded list ensures efficient data retrieval and indexing.

Changing the direct inheritance class for each Declare Index class to the Line Item data type allows for proper data management and querying.

 References:

Pega best practices for data modeling and indexing recommend using Declare Index for embedded lists to enhance performance and data organization.

 Therefore, the correct answer is:

D. Case Types A and B both possess an embedded list of line items. Define a Declare Index against each embedded list. Change the direct inheritance class for each Declare Index class to the Line Item data type.

Configure Activity for Background Execution:

Set the activity to execute in the background to prevent user interface delays.

Activity Setup:

Configure an activity that handles the connector call.

Declare Trigger:

Set up a declare trigger that activates when the case status changes to ensure the connector runs at the appropriate time.

Defining a case type within a case type-specific ruleset provides several advantages:

Branch Ruleset Association: By associating each branch ruleset with case-specific user stories, you can better manage development and testing. This allows for more targeted reviews and testing, ensuring that changes are isolated and easily traceable.

Component Application Conversion: If there is a possibility that the case type might be converted to a component application in the future, having a case-specific ruleset simplifies the process. It allows the case type to be more easily packaged and reused across different applications.

References: Pega Platform best practices for ruleset management and case type design.

In Pega, reusable sections should be configured in a way that promotes reuse across different applications. By placing the PartDetails section in an Enterprise ruleset within the Inventory application's Parts data class, you ensure that the section can be reused by both the Inventory and Order Fulfillment applications.References:

Pega Best Practices for Reusability: Pega Reusability

 Identify the Target Audience: To ensure that the advertisement targets customers in the eastern region, you need to define a specific customer segment that includes customers residing in that area.

 Customer Segment Configuration: In Pega's Next-Best-Action Designer, customer segments allow you to group customers based on specific attributes, such as location, ensuring that only the relevant audience sees the offer.

 Implementation: Configure the customer segment by setting the geographic criteria to include customers from the eastern region.

 Reference: Pega Marketing and Customer Decision Hub documentation emphasize the use of customer segments to personalize and target offers effectively (Pega Customer Decision Hub, Segmentation and Targeting).

The primary reason for developing a set of unit test cases and automated testing suites in a CI/CD model is:

C. Automated testing programmatically ensures quality of rules to maintain the integrity of the pipeline.

Automated testing helps ensure the quality and correctness of the rules being deployed. It verifies that changes do not introduce errors and maintains the integrity of the pipeline by catching issues early in the development cycle.

References:

Pega Documentation on CI/CD: CI/CD

When deciding between a wait shape and an assignment with an SLA, consider the following requirements where a wait shape is simpler:

Adjust the Case Urgency: The wait shape allows you to adjust the urgency of a case when the wait condition is defined, which is simpler than configuring an SLA.

Manual Override: The wait shape provides an option to manually step past the waiting point if necessary, making it more flexible for certain scenarios.

References:

Wait Shape

Service Level Agreements

Identifying the Error Flow:

When stages are altered in a case type, in-flight cases can encounter issues if they try to advance to a now-missing stage.

pzStageProblems Flow:

This flow is initiated when there are problems advancing stages due to missing or reconfigured stages.

It helps to manage and resolve issues related to stage progression.

References:

Pega Platform Case Management Documentation

Pega Academy Course on Advanced Case Design

Aggregation components in a decision strategy are used to:

Perform Calculations:

Aggregation components are designed to calculate values based on a list of actions or records.

Examples include summing up totals, calculating averages, or other statistical measures.

Use Cases:

Commonly used to aggregate customer interaction data, such as total purchases, average spend, etc.

Strategy Implementation:

Place the Aggregation component in the strategy where calculations are required.

Configure the aggregation logic (e.g., sum, average).

References: Pega Decisioning Aggregation Components Guide

 Increasing Stage Upweighting: This technique involves gradually increasing the priority or weight of offers in a specific stage of the customer journey, promoting active engagement and progression through the journey stages.

 Second Stage: In the second stage, which presents available offers, enabling increasing stage upweighting ensures that offers are promoted more actively over time, enhancing visibility and uptake.

 Reference: Pega's customer journey framework and decision strategies documentation detail how to use stage upweighting to optimize customer engagement and offer promotion (Pega Customer Decision Hub, Customer Journey and Engagement Strategies).

Queue Processors in Pega: Queue processors are responsible for asynchronous processing of queued tasks. They can be configured to run on different types of nodes.

Types of Nodes:

Web user nodes: Handle user requests.

Real-time nodes: Handle real-time processing tasks.

Background nodes: Handle background processes such as agents and queue processors.

Stream nodes: Handle stream processing and Kafka services.

Potential Root Cause: If a queue processor is not running, it is likely due to an issue with the node type that handles background processes, which are the background nodes. If the background node is down, the queue processor will not function properly.

References:

Pega documentation on node types and their functions.

Pega Platform 8.x help files related to queue processors and background processing.

To address difficulty in creating a customer service request through Facebook Messenger:

Change the text analyzer configured for the channel (Answer C):

Explanation: The text analyzer is responsible for interpreting user input. Improving its configuration can enhance its ability to understand and process customer requests more accurately.

To create a new control with a shortcut key:

Create a new autogenerated button control and alter its caption to support a shortcut key (Answer A):

Explanation: Using autogenerated controls ensures consistency with Pega’s UI framework, and adding a shortcut key to the caption makes the button accessible via keyboard shortcuts.

A rule defined in myco-data-shape-rectangle can modify the .Color property because .Color is defined in the parent class (myco-data-shape) and is inherited by its subclasses.

A rule existing in myco-data-shape can be overridden in myco-data-shape-circle, allowing for specific behavior in the subclass while maintaining the inheritance structure.

 Service Request Processor for Asynchronous Processing:

Configuring a REST service to run asynchronously using a service request processor ensures that the service runs without making the external application wait. The system returns a unique identifier instantly and processes the request in the background.

 References:

Pega's best practices for REST services and asynchronous processing recommend using service request processors for handling long-running processes.

 Therefore, the correct answer is:

B. A REST service that runs asynchronously by using a service request processor.

Navigate to Field Level Auditing:

Go to the work management landing page in Pega.

Field Level Auditing Tab:

On the Field Level Auditing tab, configure the source field with "suggested generic substitute (.GenericCode)".

This ensures both the label and property name are recorded in the history details.

 Ensuring Quality with Automated Testing:

Automated testing programmatically ensures the quality of rules, maintaining the integrity of the CI/CD pipeline. This is crucial for consistent and reliable deployments.

 References:

Pega Lead System Architect documentation emphasizes the importance of automated testing in CI/CD models to ensure rule quality and pipeline integrity.

 Therefore, the correct answer is:

B. Automated testing programmatically ensures quality of rules to maintain the integrity of the pipeline.

To ensure that private information is secured and only visible to limited users, creating an access control policy is the recommended approach. Access control policies allow you to define specific conditions and constraints under which sensitive data can be accessed, ensuring that only authorized users can view or modify this information.

References:

Pega Security: Access Control Policies

Pega Data Security: Securing Sensitive Information

Setting the Rule security mode on the access group to Deny ensures that:

Privileged Access Only: It enforces that all rules which can specify a privilege must have a privilege assigned. This ensures that only users with the appropriate privileges can execute these rules.

Security Compliance: This setting helps in maintaining strict security compliance by not allowing default access to rules without explicit privilege checks.

References:

Pega Rule Security Mode

For processing weekly CSV files of customer insurance quotes and creating policy cases:

File Listener and Job Scheduler (D):

Use a file listener to read the incoming CSV file and feed the data into a data type.

Configure a job scheduler to read the records from the data type and create cases. This approach decouples the file reading and case creation processes, allowing for better control and error handling.

References:

Pega File Listener Configuration Guide

Pega Job Scheduler Documentation

Several factors can contribute to delays in sending correspondence in a Pega application:

Queued SLA Objects: The number of Service Level Agreement (SLA) objects queued can affect the timing of correspondence. If there are many SLA objects queued, the system may take longer to process them, leading to delays.

Error Handling for Locked Items: If there are errors in handling locked items, this can also cause delays. When an item is locked and an error occurs, the system needs to manage these exceptions, which can impact the overall processing time.

References: Pega Platform documentation on SLA and error handling mechanisms.

The load-datapage activity method is used to initiate the loading of a data page. This method ensures that the data page is populated with the required data by executing its defined source. References:

Pega Documentation on Data Pages: Data Pages

To maximize flexibility for business users to create reports that retrieve data from several related classes in Pega Platform:

Association Rules:

Association rules define the relationships between different classes. They allow users to create reports that join data from multiple classes.

The Lead System Architect (LSA) is responsible for ensuring these association rules are defined and maintained in the application.

Creating Reports:

Once the associations are in place, business users can leverage these relationships to create complex reports without needing deep technical knowledge.

This enables users to pull in data from various related classes seamlessly.

References:

Pega Platform Reporting Guide

Pega Best Practices for Data Modeling

 Automated Pega Unit Tests:

Having new team members create and run automated Pega unit tests against their rules ensures that they adhere to best practices and catch errors early.

 Rule Check-In Approval Process:

Using the rule check-in approval process allows for a review of changes made by new team members, ensuring that all rules meet the required standards and best practices.

 References:

Pega best practices for rule management and team collaboration recommend these approaches to maintain code quality and adherence to standards.

 Therefore, the correct answers are:

A. Have new team members create and run automated Pega unit tests against their rules.

C. Use the rule check-in approval process to review the changes that the new team members make.

To avoid recalculating declarative properties when extracting data with BIX:

BIX Command Line Options:

The BIX extraction process can be configured to disable recalculating declarative properties by using specific command line options.

The options disableBackwardChaining and disableForwardChaining prevent the recalculation of declarative properties during the extraction.

Configuration:

Include these options in the BIX command line execution to ensure that declarative properties are not recalculated from their source properties during the extraction process.

References:

Pega Business Intelligence Exchange (BIX) User Guide

Pega Documentation on Declarative Rules

To meet the requirement that only the work group manager can read and write purchase request cases when the total amount exceeds USD 10,000, the following configurations can be used:

Reads Access Control Policy: Use a reads access control policy with a condition that checks if the amount is less than USD 10,000. This restricts access based on the purchase request amount.

Conditional Access in Access Manager: Configure conditional access in Access Manager to allow read and write permissions for purchase request cases only when the amount is less than USD 10,000. References:

Pega Documentation on Access Control Policies: Access Control Policies

Pega Access Manager: Access Manager

Enable Auditing:

On the Rule-Declare-Decision Table RuleForm, check the option to enable auditing.

Monitor Changes:

This configuration will track changes made to the decision table in the production environment.

For Pega Web Mashup to follow the same-origin policy, both the web application page URL and the Pega gadget URL must have the same origin, which includes the same scheme (HTTP/HTTPS), host, and port.

Configuration A and Configuration B:

Web application page URL: https://www.pega.com/MyWebApp/home.html

PEGA Gadget URL: https://www.pega.com/MyWebApp/gadgetA.html

In both configurations A and B, the scheme (https), host (www.pega.com), and port (default HTTPS port 443) are the same, which adheres to the same-origin policy.

References:

Pega Web Mashup and Same-Origin Policy

 Edit Input Rule: Create an Edit input rule on the customerinfo property. This rule will automatically convert the first and last names to upper case when the data is entered or updated, ensuring consistency.

 Data Transform: Develop a post-processing Data Transform that converts the names to upper case. This Data Transform can be invoked in the flow action to ensure that the names are converted after the user submits the form.

References:

Pega Academy: Configuring Data Transforms and Edit Input Rules

Pega Documentation: Data Transform Rules

To implement integration of system of record data for account information in a Pega Customer Service application:

Specialize the Pega Customer Service data pages that use account data to ensure they are tailored to fetch the required data.

Integrate with the system of record to populate an Account data class, ensuring that account information is correctly retrieved and stored.

Create a data transform to map the Account data class to the Pega Customer Service Account class, ensuring that data is correctly transformed and utilized within the Pega application.

Configure Table Edit:

Go to the .Title property in the Data Model.

Set the table edit option to reference the valid field values.

Decision Table Validation:

Ensure that the decision tables are set up to validate against these field values automatically.

This will help prevent incorrect spellings and ensure data integrity.

References:

Pega Academy: Data Validation and Integrity.

Pega Documentation: Decision Tables and Field Value Validation.

To troubleshoot a chronic performance issue in a cloud-based production application:

Review Performance Alerts and Exceptions in PDC (A): Pega Predictive Diagnostic Cloud (PDC) monitors and reports on the health and performance of Pega applications in real-time. Reviewing alerts and exceptions here can provide insights into the root causes of performance issues.

Review Performance Alerts and Exceptions in AES (D): Pega Autonomic Event Services (AES) also monitors system health and performance. It can help identify patterns and issues that occur during specific time frames.

References:

Pega PDC: Understanding Pega Predictive Diagnostic Cloud

Pega AES: Pega Autonomic Event Services Overview

To address the complaints from customers and prospects about receiving irrelevant offers and products, the following two Pega solutions can be implemented:

Pega Marketing: This solution helps in creating personalized marketing campaigns. By leveraging predictive analytics and customer data, it ensures that the marketing efforts are relevant and targeted. This reduces the chances of customers receiving irrelevant offers.

Customer Decision Hub: This hub centralizes the decision-making process by using real-time data and analytics to personalize interactions with customers. It helps in understanding customer needs and preferences better, thus preventing the delivery of irrelevant offers.

References:

Pega Marketing Overview

Customer Decision Hub

Identifying and resolving out-of-memory errors in a cluster node involves understanding the alerts that typically precede such conditions.

PEGA0004 – Quantity of data received by database query exceeds limit (Answer A):

Explanation: This alert indicates that a database query is returning more data than expected, which can lead to memory issues as the system tries to handle large data sets.

In attribute-based access control (ABAC) configuration, if you need to evaluate attributes from a data page, you should use the data page as the policy condition value in the access control policy condition. This allows the system to evaluate the current value from the data page when enforcing access control rules.

 Extending Core Pega Classes:

Extending existing core Pega Platform classes such as Data-Party-Person, Data-Party-Com, and Data-Address-Postal ensures that the application adheres to standard Pega data models.

Persisting instances of these extended classes in the PegaData schema aligns with best practices for data persistence and reuse.

 References:

Pega Lead System Architect documentation on data modeling recommends extending core Pega classes to maintain consistency and leverage built-in functionalities.

 Therefore, the correct answer is:

A. Extend existing core Pega Platform classes such as Data-Party-Person, Data-Party-Com, and Data-Address-Postal, persisting instances of the extended classes in the PegaData schema.

To expose a set of services for your application, with each service exposed as a separate WSDL:

Create a separate service package for each WSDL (Answer A):

Explanation: Service packages in Pega allow you to group related services and generate WSDL files for them. By creating a separate service package for each WSDL, you can manage and expose each service independently.

 Setting pxThread.isWebMashup:

In the pyDefault Data Transform for a case, setting pxThread.isWebMashup to True ensures that App Studio users see the same views displayed by a Mashup interface.

 Associated Privilege Visibility Conditions:

Using associated privilege visibility conditions allows App Studio users to view and configure sections only shown to external personas at design time.

 References:

Pega documentation on Mashup interface development in App Studio outlines these practices to ensure seamless integration and development.

 Therefore, the correct answers are:

B. In the pyDefault Data Transform for a case, set pxThread.isWebMashup to True by using an Application Setting. App Studio users then see the same views that are displayed by a Mashup interface when it is configured to use the Create a case option.

C. Use associated privilege visibility conditions. At design time, an App Studio user is able to view and configure sections that are only shown to external personas.

To ensure that all development teams (A, B, and C) are working with the latest version of the shared rulebase, the tasks should be ordered as follows:

Team A publishes the branch to the system of record.

The system of record triggers the job on the automation server.

Automation server requests conflict detection.

The automation server merges the branch to the system of record.

Teams B and C import the application rules within their local environment.

Step by Step Comprehensive Detailed Explanation:

Team A publishes the branch to the system of record:

Explanation: Team A needs to publish their changes to the central repository (system of record) to make them available for integration and further processing.

The system of record triggers the job on the automation server:

Explanation: Once the branch is published, the system of record initiates an automated process to handle the new changes. This step triggers the automation server to start its job.

Automation server requests conflict detection:

Explanation: The automation server needs to check for any conflicts between the newly published branch and the existing codebase. This ensures that any issues are identified and resolved before merging.

The automation server merges the branch to the system of record:

Explanation: After conflict detection and resolution, the automation server merges the changes from the branch into the main codebase in the system of record.

Teams B and C import the application rules within their local environment:

Explanation: Once the merge is complete, Teams B and C can import the updated application rules into their local environments to ensure they are working with the latest version of the rulebase.

References: According to Pega’s best practices for managing distributed development teams, this sequence ensures that changes are properly integrated and conflict-free before being distributed to other teams, promoting consistency and minimizing integration issues.

For modeling different types of vehicles in an insurance quote application:

Separate Data Types:

Create a distinct data type for each vehicle type (e.g., Car, Motorcycle, Truck). This allows for specific properties and business logic for each vehicle type.

Single Vehicle Page List:

Maintain a single page list property in the quote case type to hold vehicle details.

At runtime, dynamically identify the page class for each entry in the list based on the type of vehicle being processed. This approach allows for flexibility and maintainability.

References:

Pega Data Modeling Best Practices

Pega Case Management Guide

To restrict the ability to withdraw a case to specific users, the following rule types can be used in combination:

Access When (Answer B):

Explanation: An Access When rule can be created to conditionally grant or deny access to the withdraw action based on the user's role and whether they are the creator of the case or a work group manager.

Create Site-Specific Encrypting Cypher:

Go to Designer Studio > Data Model > Classes > Class Groups.

Select the class group for MyOrg-HR-Work-RFP.

In the Security section, configure the site-specific encrypting cypher.

Select Encrypt BLOB?:

Check the option Encrypt BLOB? to ensure the storage stream for the class is encrypted.

Configuration:

Ensure the encrypting cypher is correctly set up and applied to the specific class.

Validate the configuration by checking the encryption of data in the database.

References:

Pega Academy: Data Encryption.

Pega Documentation: Encrypting the Storage Stream.

Graphical user interface, text, application Description automatically generated

A rule-utility-function (RUF) has the advantage of being directly callable from a decision table, which is a common requirement in Pega applications for implementing business logic. This direct invocation capability simplifies the design and execution of decision rules. References:

Pega Rule-Utility-Functions: Rule-Utility-Functions

To address complaints about irrelevant offers and products:

Pega Marketing (A): This solution helps create targeted marketing campaigns and personalized offers, ensuring that customers receive relevant and timely promotions.

Customer Decision Hub (D): This solution uses real-time analytics and decisioning to determine the best action or offer for each customer, ensuring relevance and improving customer satisfaction.

References:

Pega Marketing: Pega Marketing Overview

Customer Decision Hub: Pega Customer Decision Hub

Runtime Class Variability:

At runtime, the .Loans page list can contain instances of different classes (e.g., MyCo-data-Loan-Auto and MyCo-data-Loan-Mortgage).

Class Consistency:

While the page list can contain different instances, all pages must conform to the defined class structure.

Specialized Rule Reference:

Specialized rules in MyCo-Data-Loan-Mortgage can be referenced through .Loans, provided they are defined within the class hierarchy.

To improve the guardrails compliance score of an application, you can perform the following actions:

Ensure keyed data classes are not mapped to pr-other where possible:

Pega recommends avoiding the use of the pr_other table for keyed data classes as it can lead to performance issues and complicate data retrieval.

Instead, ensure that keyed data classes are mapped to dedicated tables. This enhances data management and improves compliance with Pega’s best practices.

Convert activities that only retrieve data to data transforms that invoke data pages:

Activities in Pega can be complex and harder to maintain. When activities are only used to retrieve data, it’s better to convert them to data transforms that call data pages.

Data pages are reusable and declarative. They help in maintaining consistency and reducing the complexity of the application.

References:

Pega Documentation on Data Classes: Data Classes

Pega Documentation on Data Pages and Data Transforms: Data Pages

The Exclude Operators option in the Security Policies landing page allows administrators to specify certain operators, such as Admin or Executive roles, who should be exempt from the lockout policy. This ensures that critical users retain access even after multiple failed login attempts, aligning with the requirement to exclude specific roles from lockout policies.

References:

Pega Security Policies: Configuring Security Policies

Pega Authentication: Authentication and Access Control

The system will consider the assignments with urgency value equal to and greater than the specified value in the Operator rule. Once all assignments are processed from the work queue based on the threshold urgency value, the lower urgency assignments are then considered.

Urgency Thresholds: The system checks the urgency of assignments in each work queue. Assignments with an urgency equal to or greater than the threshold are considered first.

Get from Work Queues First: With this option selected, the system prioritizes processing work queues before considering individual workbaskets.

Lower Urgency Assignments: After processing assignments meeting the urgency thresholds, the system will then consider lower urgency assignments if there are no higher urgency tasks left.

Activities and functions in Pega share certain common features which are vital for their flexibility and maintainability.

Parameterization: Both activities and functions can be parameterized, allowing them to accept input values when they are invoked. This makes them reusable in different contexts by simply changing the parameters.

Versioning: Both activities and functions support versioning. This means you can maintain different versions of an activity or function, which is useful for keeping track of changes and ensuring compatibility with different versions of the application.

References: Pega Platform documentation on activities and functions.

To minimize potential development conflicts and ensure that both development teams work with the most current version of the Policy Administration application, the following best practices should be followed:

Perform Branch Reviews when Merging Branches (A):

Regularly review and validate changes made in branches before merging them into the mainline. This ensures that any conflicts or issues are identified and resolved early in the development process.

Branch reviews help maintain code quality and prevent integration problems.

Periodically Sync the Policy Administration Application Code (D):

Synchronize the Policy Administration application code regularly to ensure that the Quoting application team is working with the latest version.

This practice helps to avoid discrepancies and ensures that enhancements and updates in the Policy Administration application are consistently reflected in the Quoting application.

References:

Pega Platform Best Practices for Branching and Merging

Pega Application Development Guide

To configure a data page that caches customer transactions and minimizes operator wait time, you should:

Set the data page scope to node to ensure that the cached data is shared among all requestors on the same node, reducing the number of times the data needs to be fetched.

Configure the refresh strategy to reload if the data is older than 1 hour, aligning with the data update frequency and ensuring that the data is not stale.

To ensure the performance of the Pega application does not degrade over time, consider the following recommendations:

Maintain Fragmented Tables: Schedule scripts to regularly maintain and defragment tables that are frequently updated. This helps in optimizing database performance.

Purge and Archive Records: Implement purging and archiving strategies based on the company's record retention policy. This practice helps in managing data growth and ensures that the system remains performant over time.

References:

Database Maintenance

Data Archiving

 Declare Expression: Use a Declare Expression to calculate the sum of the columns and store the result in an additional property. This ensures that the sum is always updated when any of the contributing values change.

 Report Configuration: Configure the report to group by the columns to be summed and use the SUM function for aggregation. This approach leverages Pega’s reporting capabilities to dynamically compute and display the sum based on the selected columns.

References:

Pega Academy: Advanced Reporting Techniques

Pega Documentation: Declare Expressions and Reporting

To configure the application to handle the requirement where employees can designate alternate operators to perform their work while they are on vacation, follow these steps:

Define a custom Access When rule:

Create an Access When rule named pxAssignedToMeOrAlternate. This rule will allow the system to check whether the assignment is for the current user or their designated alternate.

The rule should include logic to determine if the assignment belongs to the operator or the operator’s alternate.

Modify the pyUserWorkList Report Definition:

Access the pyUserWorkList report definition which is used to display the worklist for the current user.

Modify this report to include a filter condition using the pxAssignedToMeOrAlternate Access When rule. This ensures that the report displays assignments for both the current user and any assignments for which they are an alternate.

Assign Worklist assignments to alternate operators:

Ensure that the assignments visibility is adjusted accordingly by modifying the security settings to allow access to assignments for alternate operators.

Testing and Verification:

Test the configuration to ensure that alternate operators can see and access the worklist items of the operators they are covering for.

This approach leverages Pega’s Access When rules to dynamically adjust the visibility of assignments based on operator relationships, ensuring that alternate operators can perform work as needed without requiring manual assignment transfers.

References:

Pega Documentation on Access When rules: Access When Rules

Pega Documentation on Report Definitions: Report Definitions

Next-Best-Action Configuration:

In Pega, configure the Next-Best-Action strategy to include customer lifetime value as a factor.

Set Thresholds:

Define thresholds for customer lifetime value to determine what constitutes a high-value proposition.

Prioritization Logic:

Implement logic within the strategy to prioritize actions or offers that align with high customer lifetime value.

Regarding inbound email processing:

An incoming email reply is linked to its original case by the case ID in the subject of the email (Answer A):

Explanation: The case ID in the subject line allows the system to match the incoming email with the existing case, ensuring proper tracking and processing.

Configure Authentication Activity:

Go to Records Explorer > Security > Activities.

Create or configure the authentication activity to map the authenticated user to the operator ID in Pega.

LDAP Attributes Mapping:

Go to Designer Studio > Security > Authentication Service.

Configure the LDAP attributes to map to Pega operator properties, ensuring that attributes like cn, sn, mail, etc., are correctly mapped.

Validation:

Test the Single Sign-On (SSO) setup to ensure the authentication and attribute mappings work correctly.

Verify that users can log in using SSO and their LDAP attributes are correctly reflected in Pega.

References:

Pega Academy: Single Sign-On Configuration.

Pega Documentation: LDAP and SSO Configuration.

 The decision table provided in the question lists rules for segmenting customers based on their credit score and average balance.

 For a customer with a credit score of 240 and an average balance of 35000:

The first rule checks if the credit score is >= 400 and < 600, and average balance >= 30000. This rule doesn't apply as the credit score is 240.

The second rule checks if the credit score is >= 200 and < 400, and average balance >= 20000. This rule applies since the credit score is 240 and average balance is 35000.

 According to this rule, the result is "Fair".

 Therefore, the label returned for a customer with a credit score of 240 and an average balance of 35000 is "Fair".

To ensure claim processors work on the most urgent claims first, consider the following approach:

Advanced Agent: Implement an advanced agent on a dedicated node to increment the pyUrgencyAssignAdjust value by 1 for each assignment that meets the selection criteria. This agent can run at the start of each day to update the urgency of all claims in the PendingProcessing workbasket.

Dedicated Node: Using a dedicated node ensures that the urgency update process does not interfere with other application processes and can handle the large volume of claims efficiently.

References: Pega Platform documentation on advanced agents and configuring assignment urgency.

Content Security Policies (CSP) are defined to enhance the security of web applications by preventing the browser from loading content from untrusted sources. This helps mitigate cross-site scripting (XSS) and other code injection attacks.

Prevention of Untrusted Sources: CSPs are primarily used to specify which sources of content are trusted and can be loaded by the browser. This includes scripts, stylesheets, images, etc.

References:

Content Security Policy (CSP)

 Job Scheduler with SendEmailNotification Utility:

Running a job scheduler to pull customer records matching the current date and using the SendEmailNotification utility ensures that emails are sent out at midnight. Recording failures in a data type captures the necessary error information.

 Job Scheduler with CorrNew Utility:

Using the CorrNew utility to send emails and record any exceptions in a data type also satisfies the requirement for recording email delivery failures.

 References:

Pega documentation on job schedulers and email utilities provides guidelines for implementing scheduled tasks and handling email delivery.

 Therefore, the correct answers are:

B. Run a job scheduler, and pull the customers that match the current date. For each record, invoke the SendEmailNotification utility. If any exception is received in email delivery, mark the failure in a data type.

D. Run a job scheduler, and pull the customers that match the current date. For each record, invoke the CorrNew utility. If any exception is received in email delivery, mark the failure in a data type.

Applicability:Applicability rules ensure that the right offers are presented to the right customers. If Anna holds a higher value card (Premier Rewards), the new Rewards card offer might not be applicable to her because it is a lower-tier product.

Configuration Steps:

Define applicability criteria for each offer.

Ensure that offers are presented based on customer profiles and existing products.

References:Pega Academy lessons on Offer Management explain the role of applicability rules in ensuring that relevant offers are presented to customers.