PEGACPLSA23V1 Application Design Extended

Application Design Extended Detailed Explanation

4.1 Work Assignment and Routing

In Pega, Work Assignment and Routing determine how tasks are assigned to the right users or teams based on predefined logic. Efficient routing ensures that work is processed by the most appropriate resource, improving productivity and meeting SLAs.

Key Topics in Work Assignment and Routing

1. Routing Strategies
   • Skill-Based Routing
   • Role-Based Routing
   • Dynamic Routing using Decision Tables or Data Pages
2. Work Queues (Workbaskets)
3. Workload Balancing

4.1.1 Routing Strategies

What is Routing?

Routing is the process of assigning work to users, teams, or queues based on business logic or conditions. Pega provides several routing strategies to ensure tasks are delivered to the right individuals or work queues.

Types of Routing Strategies

1. Skill-Based Routing
2. Role-Based Routing
3. Dynamic Routing

1. Skill-Based Routing

Definition

Skill-Based Routing assigns tasks to users based on their skills or competencies. This ensures that specialized work is routed to team members with the required expertise.

How It Works

1. Define skills in Pega for specific users.
2. Tag assignments with the required skill(s).
3. Pega matches users to assignments based on their skills.

Example: IT Support Desk

Scenario: Assign support tickets to agents based on their technical skills.

Agent	Skills
Alice	Network Troubleshooting
Bob	Database Support
Charlie	Software Issues

Routing Logic:

• Tickets tagged as “Database Issue” are routed to Bob.
• Tickets tagged as “Network Issue” are routed to Alice.

Steps to Configure Skill-Based Routing

1. Define Skills:
   • In Pega, go to Operator Record → Add skills (e.g., Network Support, Database Support).
2. Tag Assignment:
   • In the process flow, configure the Assignment Shape → Add required skills for the task.
3. Route Based on Skills:
   • Use To Skilled User in the Routing configuration of the assignment.

Benefits of Skill-Based Routing

1. Ensures tasks are handled by qualified users.
2. Improves work quality and efficiency.
3. Reduces task reassignment due to lack of expertise.

2. Role-Based Routing

Definition

Role-Based Routing assigns tasks to users based on their roles or access groups in the organization.

How It Works

1. Assign users to roles (e.g., Manager, Approver, Reviewer).
2. Route work to individuals or groups based on their roles.

Example: Loan Approval Process

Scenario: Approve loan applications based on roles.

Role	User
Loan Reviewer	John, Mary
Loan Approver	Sarah

Routing Logic:

• Tasks for “Document Verification” are routed to users with the Loan Reviewer role.
• Tasks for “Final Approval” are routed to the Loan Approver role.

Steps to Configure Role-Based Routing

1. Assign Roles:
   • Go to Access Group → Define roles (e.g., Manager, Approver).
2. Configure Assignment:
   • In the process flow, use the Route To option and specify “Work Group” or “Role.”

Benefits of Role-Based Routing

1. Simplifies routing for teams with clear roles.
2. Ensures role-specific tasks are assigned correctly.
3. Reduces the risk of task misassignment.

3. Dynamic Routing

Definition

Dynamic Routing determines the task recipient at runtime using business logic, decision rules, or data sources.

How It Works

• Pega uses Decision Tables, Decision Trees, or Data Pages to decide the assignment dynamically based on real-time conditions.

Example: Insurance Claim Assignment

Scenario: Route insurance claims based on claim type and priority.

Dynamic Logic:

Condition	Assigned To
Claim Type = “Auto” AND Priority = High	Senior Adjuster
Claim Type = “Health”	Health Claims Team
Claim Type = “Auto”	Auto Claims Team

Steps to Configure Dynamic Routing

1. Create Decision Logic:
   • Use a Decision Table or Data Page to define routing conditions.
2. Reference Logic in Flow:
   • In the Assignment Shape, choose Route To → Use a Decision Table or Data Page.

Benefits of Dynamic Routing

1. Provides flexibility to adapt routing based on real-time data.
2. Ensures tasks are routed accurately based on complex conditions.
3. Reduces manual intervention in work assignments.

4.1.2 Work Queues (Workbaskets)

What is a Work Queue?

A Work Queue (formerly known as Workbasket) is a shared queue where assignments are pooled for a group of users. Team members can pull tasks from the queue based on priority.

How Work Queues Work

1. Assign tasks to a Work Queue instead of a specific user.
2. Team members access the queue and work on tasks based on availability.
3. Pega can automatically assign tasks from the queue using workload balancing rules.

Example: Customer Support Work Queue

Scenario: Route support tickets to a shared Customer Support Queue.

Work Queue	Assigned To
General Support Queue	Support Team A (3 users)
Technical Support Queue	Support Team B (2 users)

• All tickets are added to the General Support Queue.
• Team A members pick tickets from the queue.
• If a ticket is marked as “Technical,” it is routed to the Technical Support Queue.

Benefits of Work Queues

1. Improves teamwork by pooling assignments.
2. Ensures tasks are accessible to multiple users.
3. Reduces idle time by allowing team members to pick tasks.

4.1.3 Workload Balancing

What is Workload Balancing?

Workload Balancing ensures that tasks are distributed evenly among team members to avoid overloading individuals.

How It Works

1. Tasks in a Work Queue can be automatically assigned to users based on:

   • Availability: Assign work to idle users first.
   • Workload: Assign work based on the current number of tasks.

2. Configure Routing Rules in Pega to distribute tasks fairly.

Example: Claims Processing Team

Scenario: Distribute claims processing tasks evenly among team members.

Team Member	Current Task Count	Next Assignment
Alice	2	Yes
Bob	1	Yes
Charlie	4	No

Logic:

• Assign tasks to users with the least number of active tasks.

Benefits of Workload Balancing

1. Ensures fair distribution of tasks.
2. Prevents individual overload and reduces burnout.
3. Improves team efficiency by balancing work evenly.

Summary of Work Assignment and Routing

1. Routing Strategies:

   • Skill-Based Routing: Assign tasks based on user skills.
   • Role-Based Routing: Assign tasks based on user roles.
   • Dynamic Routing: Use decision logic or data pages for real-time routing.

2. Work Queues:

   • Pool assignments in shared queues for team-based processing.

3. Workload Balancing:

   • Distribute tasks evenly to improve productivity and prevent overload.

4.2 Case Participation and Collaboration

In Pega, Case Participation refers to defining roles for users who interact with cases, while Collaboration tools allow users to communicate, share information, and track changes efficiently within the case. Together, these features ensure better teamwork, accountability, and visibility across processes.

Key Topics in Case Participation and Collaboration

1. Case Participants
2. Pulse Collaboration
3. Case Audit Trail

4.2.1 Case Participants

What are Case Participants?

Case Participants are the users or roles involved in processing a case. Each participant has specific permissions and responsibilities depending on their role.

Types of Case Participants

1. Case Workers:

   • Users who perform tasks in a case (e.g., agents, processors).
   • Example: A “Loan Officer” verifies documents in a loan application.

2. Case Managers:

   • Supervisors who monitor case progress, approve decisions, and manage escalations.
   • Example: A “Manager” approves loan applications over $50,000.

3. Reviewers:

   • Users who review case information but do not perform tasks.
   • Example: An auditor reviews approved loans for compliance.

4. External Users:

   • Users outside the organization who interact with the case.
   • Example: Customers submit applications or documents via a portal.

Defining Case Participants

In Pega, you define participants by assigning roles to users or work groups. Roles determine what actions a user can perform within the case.

Example: Loan Application Case

Role	Participant	Responsibilities
Case Worker	Loan Officer	Collect and verify documents.
Case Manager	Senior Loan Manager	Approve or reject applications.
Reviewer	Internal Auditor	Review approved loans for compliance.
External User	Customer	Submit loan applications.

Steps to Configure Case Participants

1. Define Roles:

   • Go to Access Groups → Create roles (e.g., LoanOfficer, Approver).

2. Assign Roles to Users:

   • Link roles to operator IDs or work groups.

3. Restrict Access:

   • Configure access permissions for each role (e.g., view, update, or approve cases).

4. Role-Based Routing:

   • Use roles to route tasks to the appropriate participants.

Benefits of Defining Case Participants

1. Clear Responsibilities: Ensures everyone knows their role and tasks.
2. Improved Accountability: Tracks who performed or approved specific actions.
3. Better Organization: Roles help organize workflows and prevent unauthorized actions.

4.2.2 Pulse Collaboration

What is Pulse?

Pulse is Pega’s built-in collaboration tool that allows users to communicate and share information within a case. It works like a chat or comment system to facilitate discussions and decisions.

Pulse Features

1. Contextual Collaboration:

   • Comments are attached directly to the case, making it easy to track discussions.

2. Mentions (@):

   • Use @mentions to notify specific users or teams.
   • Example: @LoanManager Please review this case.

3. File Attachments:

   • Attach files, screenshots, or documents to comments.
   • Example: Attach a customer’s ID proof for reference.

4. Visibility Settings:

   • Control who can see Pulse comments:
     • Private: Visible only to specific users.
     • Public: Visible to all case participants.

5. Notifications:

   • Users receive notifications when they are mentioned or when comments are added to cases they follow.

Example: Using Pulse in a Loan Application

Scenario: A loan officer finds missing information in a customer’s loan application.

1. Loan Officer adds a Pulse comment:

   • @Customer Please upload your income statement.

2. Manager adds a note for escalation:

   • @LoanManager This application needs urgent review due to missing documents.

3. Attach files:

   • The customer uploads the document, and the loan officer attaches it to the case.

Benefits of Pulse Collaboration

1. Real-Time Communication: Facilitates quick discussions within the case.
2. Improved Documentation: Keeps a record of conversations and decisions.
3. File Sharing: Enables easy sharing of supporting documents.
4. Increased Accountability: Tracks who made comments or updates.

4.2.3 Case Audit Trail

What is the Case Audit Trail?

The Case Audit Trail is a chronological record of all user actions, system changes, and updates made to a case. It helps track who did what, when, and why, ensuring accountability and transparency.

What Does the Audit Trail Track?

1. Assignments:

   • Who worked on a task, when it was assigned, and its status.

2. Updates:

   • Changes to case data (e.g., loan amount updated from $20,000 to $25,000).

3. Approvals:

   • Who approved or rejected a task and the reason for their decision.

4. Comments:

   • Pulse comments or notes added by users.

5. SLAs and Escalations:

   • SLA events, missed deadlines, and escalations.

Example: Case Audit Trail for a Loan Application

Action	User	Date/Time	Details
Case Created	Customer	2024-06-01 10:00 AM	Loan Amount: $50,000
Task Assigned: Verify Documents	Loan Officer	2024-06-01 11:00 AM	Assigned to John
Loan Amount Updated	Loan Officer	2024-06-01 01:00 PM	Loan Amount updated to $55,000
Task Approved	Loan Manager	2024-06-02 09:00 AM	Approved with comments: OK

How to View the Audit Trail

1. Open the case in the Case Manager Portal.
2. Go to the Audit tab to see a chronological list of case events.

Benefits of the Case Audit Trail

1. Accountability: Tracks all actions for transparency.
2. Compliance: Ensures compliance with business and regulatory requirements.
3. Error Debugging: Helps identify who made changes or when an issue occurred.
4. Improved Communication: Provides visibility into case progress and history.

Summary of Case Participation and Collaboration

1. Case Participants:

   • Define roles (e.g., Case Worker, Manager, Reviewer) and assign responsibilities to users.

2. Pulse Collaboration:

   • Use Pulse for contextual discussions, @mentions, and file sharing within a case.

3. Case Audit Trail:

   • Track all user actions, updates, approvals, and escalations to ensure accountability and transparency.

4.3 Advanced Process Handling

Advanced process handling ensures that Pega applications can efficiently manage complex workflows, perform background tasks, and adapt to changing business conditions.

Key Topics in Advanced Process Handling

1. Background Processing
   • Job Schedulers
   • Queue Processors
2. Change Management
   • Circumstance Rules
3. Flows with Sub-Processes
   • Subflows
   • Split-For-Each

4.3.1 Background Processing

What is Background Processing?

Background processing enables Pega to perform automated tasks behind the scenes without user intervention. It improves performance by offloading non-interactive tasks from the main user flow.

Background Processing Tools

1. Job Schedulers
2. Queue Processors

1. Job Schedulers

Definition

A Job Scheduler is a Pega rule used to schedule recurring tasks at specific intervals (e.g., nightly, weekly). It replaces the legacy Agent method for scheduled tasks.

When to Use Job Schedulers

• Recurring tasks that need to run at a fixed schedule.
• Example: Data archiving, generating daily reports, or nightly database cleanup.

Example: Nightly Data Cleanup

Scenario: Archive completed loan applications every night.

1. Task: Identify loan cases with status Resolved-Completed and archive them.
2. Schedule: Run at 2:00 AM daily.
3. Implementation Steps:
   • Create a Job Scheduler rule.
   • Define the frequency (e.g., daily, weekly).
   • Configure an Activity to perform the task.

Benefits of Job Schedulers

1. Automates recurring tasks without manual intervention.
2. Improves system performance by running tasks during off-peak hours.
3. Provides centralized management for scheduled tasks.

2. Queue Processors

Definition

A Queue Processor handles asynchronous tasks by placing them into a queue and processing them in the background. This allows the system to handle large volumes of tasks efficiently.

When to Use Queue Processors

• Tasks that do not require immediate execution.
• High-volume processes that need to run in parallel.
• Example: Sending email notifications, data synchronization, or processing approvals.

How Queue Processors Work

1. Task Added to Queue: The system or user triggers a task.
2. Queue Processor Picks Task: Pega adds the task to a queue.
3. Processing: The Queue Processor processes tasks in the background.
4. Retries on Failure: If a task fails, the Queue Processor retries it automatically.

Example: Sending Notifications

Scenario: Send confirmation emails after a loan is approved.

1. When a loan is approved, the system triggers a Queue Processor.
2. The task (“Send Email”) is added to the queue.
3. The Queue Processor processes the task:
   • Sends the email to the customer.
4. If the email fails (e.g., server issue), the Queue Processor retries it after a short delay.

Benefits of Queue Processors

1. Improves Performance: Offloads tasks from the main flow, keeping the UI responsive.
2. Scalability: Handles large volumes of tasks efficiently.
3. Retry Mechanisms: Automatically retries failed tasks to ensure reliability.

4.3.2 Change Management

What is Change Management?

Change Management allows Pega processes to adapt to changing business conditions dynamically. It involves using Circumstance Rules to apply variations of rules based on specific conditions.

Circumstance Rules

Definition

A Circumstance Rule is a specialized version of a rule (e.g., decision table, UI form) that applies under certain conditions.

When to Use Circumstance Rules

• To customize processes for specific conditions without duplicating rules.
• Examples of conditions:
  • Customer type (e.g., VIP vs. Regular).
  • Product version (e.g., Home Loan vs. Auto Loan).
  • Region (e.g., North America vs. Europe).

Example: Loan Approval Process

Scenario: Adjust approval criteria for VIP customers.

1. Base Rule: Loan Approval requires a credit score > 700.
2. Circumstanced Rule: If Customer Type = VIP, bypass credit score verification.

Steps to Configure Circumstance Rules

1. Open the Base Rule (e.g., Decision Table).
2. Click Specialize by Circumstance.
3. Define the condition (e.g., Customer Type = VIP).
4. Configure the specialized version of the rule.

Benefits of Circumstance Rules

1. Allows process customization without duplicating rules.
2. Simplifies maintenance by managing variations centrally.
3. Improves flexibility to adapt to changing business conditions.

4.3.3 Flows with Sub-Processes

What are Sub-Processes?

Sub-Processes allow you to break down complex workflows into smaller, reusable flows. They simplify process management and improve modularity.

Types of Sub-Processes

1. Subflows
2. Split-For-Each

1. Subflows

Definition

A Subflow is a smaller flow that is called within a main flow to perform specific tasks.

Example: Loan Verification Flow

Scenario: During loan approval, call a subflow to verify documents.

• Main Flow:
  • Collect Loan Application → Verify Documents → Approve Loan.
• Subflow (Verify Documents):
  • Validate ID → Validate Income Statement → Confirm Document Validity.

Subflows are reusable and can be invoked in multiple workflows.

2. Split-For-Each

Definition

The Split-For-Each shape in Pega allows you to run tasks in parallel for a list of items.

Example: Parallel Document Verification

Scenario: Verify multiple documents (e.g., ID, income proof, property documents) simultaneously.

1. Add a Split-For-Each shape in the flow.
2. Provide the list of documents to process.
3. Tasks run in parallel:
   • Task 1: Validate ID.
   • Task 2: Validate Income Proof.
   • Task 3: Validate Property Documents.

Benefits of Sub-Processes and Split-For-Each

1. Simplifies complex workflows by breaking them into smaller, reusable flows.
2. Improves efficiency with parallel processing.
3. Enhances modularity and reusability of flows.

Summary of Advanced Process Handling

1. Background Processing:

   • Use Job Schedulers for recurring tasks (e.g., nightly cleanups).
   • Use Queue Processors for asynchronous, high-volume processing (e.g., sending notifications).

2. Change Management:

   • Use Circumstance Rules to adapt processes dynamically based on conditions.

3. Flows with Sub-Processes:

   • Use Subflows to simplify workflows.
   • Use Split-For-Each for parallel processing of tasks.

4.4 Error Handling and Recovery

Error Handling and Recovery in Pega ensures that failures, exceptions, and unexpected issues in workflows or processes are handled gracefully. It minimizes disruptions, improves user experience, and maintains system reliability.

Key Topics in Error Handling and Recovery

1. Error Handling
   • Error Handling Flows
   • Retry Mechanisms for Transient Failures
2. Recovery
   • Queue Processors with Retry Logic
   • Logging and Auditing Errors

4.4.1 Error Handling

What is Error Handling?

Error Handling involves detecting, managing, and resolving failures during process execution. Examples include:

• Missing data inputs.
• System or network issues (e.g., API failure).
• Business rule violations.

Error Handling Flows

Definition

An Error Handling Flow redirects a failed process or step to a specialized flow designed to manage the error.

When to Use Error Handling Flows

• To provide users with options when a process fails.
• To log errors for debugging and auditing purposes.
• To ensure the workflow continues or resolves gracefully after failure.

Example: Loan Approval Failure

Scenario: A loan approval step fails due to a system integration error with the credit bureau.

1. Main Flow:

   • Collect Application → Verify Credit Score → Approve Loan.

2. Error Handling Flow:

   • If the “Verify Credit Score” step fails:
     • Step 1: Log the error.
     • Step 2: Notify the system administrator via email.
     • Step 3: Provide an option to retry or manually approve the step.

Steps to Configure Error Handling Flows

1. Identify the step where failures might occur (e.g., an API integration).
2. Add an Error Flow to the process step:
   • Open the Assignment Shape → Define an alternate flow for errors.
3. In the Error Flow:
   • Log the error using a Utility Shape.
   • Send notifications or display corrective actions.

Retry Mechanisms for Transient Failures

Transient Failures are temporary issues like network glitches or timeouts. Retry mechanisms help ensure that these failures do not disrupt the workflow permanently.

How to Implement Retry Logic

1. Use Queue Processors or Job Schedulers to automatically retry failed tasks.
2. Configure retry intervals and the maximum retry attempts.
3. Log each retry attempt for debugging purposes.

Example: API Call Retry

Scenario: Fetch customer credit score via an external REST API.

• If the API call fails due to a timeout:
  • Retry the task up to 3 times with a delay of 5 minutes between retries.
  • If all retries fail, route the case to an error flow for manual intervention.

4.4.2 Recovery

What is Recovery?

Recovery ensures that failed processes or tasks are resumed and completed successfully after the root cause of the failure is resolved.

Queue Processors with Retry Logic

Queue Processors in Pega automatically manage retry mechanisms for failed tasks, ensuring reliable recovery.

How Queue Processors Handle Failures

1. Task Failure: When a queued task fails, it is marked for retry.
2. Automatic Retries: The Queue Processor retries the task based on configured rules.
   • Example: Retry every 10 minutes, up to 5 times.
3. Exhausted Retries: If retries fail, the task is moved to a broken item queue for manual resolution.
4. Recovery: Once the issue is resolved, the task can be retried manually.

Example: Sending Email Notifications

Scenario: A Queue Processor sends confirmation emails after a loan is approved.

• Failure: Email service is temporarily down.
• Automatic Retry Logic:
  • Retry every 5 minutes, up to 3 times.
• Recovery Action: If all retries fail:
  • Move the task to the broken queue.
  • Notify the administrator.

Logging and Auditing Errors

Effective logging and auditing are critical for diagnosing and recovering from errors.

What to Log?

1. Error Details:

   • Error type (e.g., API failure, missing data).
   • Error message.

2. Task Information:

   • Which task or step failed?
   • Which user or system triggered the task?

3. Retry Attempts:

   • Number of retries made.
   • Time of each retry attempt.

4. Resolution Path:

   • Whether the error was resolved automatically or manually.

Example: Logging API Errors

Scenario: Logging errors for failed API calls.

1. Create a Log Message step in the flow using the Utility Shape.
2. Include the following details:
   • “API Call Failed”
   • Error Message: “Timeout after 30 seconds.”
   • Step Name: “Fetch Credit Score.”
3. Store logs in the Pega System Log for debugging.

Benefits of Logging and Auditing

1. Provides visibility into what went wrong and why.
2. Helps developers debug and resolve issues quickly.
3. Tracks trends in errors for proactive monitoring and improvements.

Summary of Error Handling and Recovery

1. Error Handling:

   • Use Error Flows to redirect failed processes.
   • Implement retry mechanisms for transient failures.

2. Recovery:

   • Use Queue Processors with retry logic to recover failed tasks automatically.
   • Move permanently failed tasks to the broken item queue for manual intervention.

3. Logging and Auditing:

   • Log error details, retry attempts, and resolution steps to enable quick debugging and proactive monitoring.

4.5 Background and System Jobs

In Pega, Background and System Jobs allow you to automate processes that do not require user interaction. These jobs are essential for handling backend tasks like scheduled cleanups, notifications, or high-volume processing.

Key Topics in Background and System Jobs

1. Agents
2. Job Schedulers
3. Queue Processors
4. Best Practices for Background Jobs

4.5.1 Agents

What are Agents?

Agents are a legacy mechanism in Pega used for automating background tasks. Agents run predefined activities periodically or at scheduled intervals.

Note: Agents are now considered legacy. Job Schedulers and Queue Processors are the preferred methods in modern applications.

Types of Agents

1. Standard Agents:

   • Process tasks asynchronously at a scheduled interval.
   • Example: Sending email notifications.

2. Advanced Agents:

   • Provide greater control over task execution.
   • Example: Updating complex workflows in the backend.

Example: Legacy Agent for Data Cleanup

Scenario: Archive resolved loan applications every week.

1. Create an Agent Rule with a schedule of weekly execution.
2. Configure an Activity to:
   • Identify completed loan cases.
   • Archive them to a database table.

Why Move Away from Agents?

1. Limited flexibility and performance.
2. No built-in retry or failure handling.
3. Modern tools like Job Schedulers and Queue Processors offer better scalability and reliability.

4.5.2 Job Schedulers

What are Job Schedulers?

Job Schedulers are modern replacements for agents in Pega. They allow you to schedule and run recurring tasks efficiently. Job Schedulers are cluster-aware, meaning they work seamlessly across multiple nodes.

When to Use Job Schedulers

• For recurring backend tasks that require a specific schedule.
• Examples:
  • Daily cleanup of old cases.
  • Generating weekly or monthly reports.
  • Sending scheduled notifications.

Example: Generating Monthly Reports

Scenario: Generate a Monthly Loan Report for all approved loans.

1. Create a Job Scheduler Rule:

   • Name: MonthlyLoanReport.
   • Frequency: Monthly (1st of every month at 12:00 AM).

2. Configure the Task:

   • Reference an Activity to:
     • Fetch all approved loan records.
     • Generate the report and save it to a database or file repository.
     • Send the report via email to stakeholders.

Steps to Configure a Job Scheduler

1. Go to Records → SysAdmin → Job Scheduler.
2. Define the Execution Schedule (e.g., daily, weekly, monthly).
3. Configure the Task Activity: Write logic to perform the background task.
4. Test the Job Scheduler to ensure it runs as expected.

Benefits of Job Schedulers

1. Cluster Awareness: Runs on any available node in the Pega cluster.
2. Reliability: Ensures tasks run on schedule without user intervention.
3. Efficiency: Handles recurring tasks in a scalable manner.

4.5.3 Queue Processors

What are Queue Processors?

Queue Processors manage asynchronous tasks by placing them in a queue and processing them in the background. They are ideal for handling large volumes of work without blocking the main user interface.

When to Use Queue Processors

• Tasks that do not require immediate execution.
• High-volume, repetitive tasks.
• Examples:
  • Sending email notifications.
  • Processing payments.
  • Integrating with external systems (e.g., API calls).

How Queue Processors Work

1. Add Task to Queue: Tasks are added to a queue during runtime.
2. Process Task: The Queue Processor picks tasks from the queue and processes them.
3. Retries on Failure: If a task fails, the Queue Processor automatically retries it based on configured rules.

Example: Sending Confirmation Emails

Scenario: Send confirmation emails after a customer submits a loan application.

1. Add the task (“Send Email”) to the Queue Processor.
2. The Queue Processor processes the task asynchronously.
3. If the email server is unavailable:
   • Retry sending the email up to 3 times, with a 5-minute delay between attempts.

Steps to Configure Queue Processors

1. Create a Queue Processor Rule:

   • Define the task to be processed.

2. Write the Activity or logic to perform the task.

3. Add the task to the queue during runtime.

Benefits of Queue Processors

1. Asynchronous Processing: Tasks run in the background without impacting user performance.
2. Automatic Retry: Failed tasks are retried automatically to ensure completion.
3. Scalability: Processes large volumes of tasks efficiently.

4.5.4 Best Practices for Background Jobs

To ensure reliability and performance, follow these best practices:

1. Use Job Schedulers Over Agents: Job Schedulers are modern, more reliable replacements for legacy Agents.
2. Avoid Overloading Queues: Manage the volume of tasks to prevent resource exhaustion.
3. Use Retry Mechanisms: Configure automatic retries for transient failures in Queue Processors.
4. Log Task Execution: Log successful and failed executions for monitoring and debugging.
5. Optimize Schedules: Run intensive tasks during off-peak hours to minimize performance impact.
6. Monitor Background Jobs: Use Pega Predictive Diagnostic Cloud (PDC) or Admin Studio to monitor and troubleshoot jobs.

Summary of Background and System Jobs

1. Agents: Legacy method for scheduled tasks (replaced by Job Schedulers).
2. Job Schedulers: Run recurring tasks on a schedule, improving reliability and performance.
3. Queue Processors: Handle asynchronous tasks with built-in retry logic and scalability.
4. Best Practices: Optimize schedules, use retries, and log execution for monitoring.

Conclusion of Application Design Extended

We have now completed all topics in Application Design Extended:

1. Work Assignment and Routing: Skills-based, role-based, and dynamic routing.
2. Case Participation and Collaboration: Roles, Pulse collaboration, and audit trails.
3. Advanced Process Handling: Background tasks, change management, and sub-process flows.
4. Error Handling and Recovery: Error flows, retry logic, and logging.
5. Background and System Jobs: Job Schedulers, Queue Processors, and best practices.

Application Design Extended (Additional Content)

1. Routing to Work Group Pool

While basic routing strategies such as route to operator, route to work queue, and route using decision logic are typically covered, it’s important to also mention the mechanism of routing to a Work Group’s Default Work Queue — especially in dynamic workload distribution scenarios.

Key Detail:

Pega allows you to configure routing to a Work Group, which automatically places the assignment into the group's default Work Queue. This design ensures:

• Tasks are routed not to a specific user, but to a shared queue.

• Any operator associated with that Work Group and Work Queue can pull and work on the task.

• It's useful for load balancing in high-volume or rotating shift environments.

Example Use Case:

In a loan processing application, the “Verify Documents” assignment is routed to the Work Group: LoanReviewers, which has a default Work Queue called LoanReview-Q. Any user in that Work Group can work on the task based on availability.

Exam Tip:

This pattern may appear in questions involving workload distribution or routing configuration traps, where the routing target is a Work Group, not a specific queue.

2. Pulse Collaboration – Social Engagement Use Cases

Beyond its core functionality of in-app communication and collaboration, Pulse in Pega can also be extended for social engagement integrations.

Advanced Use Case:

Pulse can be customized to:

• Send notifications externally (e.g., via email or integrated messaging platforms like Slack or Microsoft Teams).

• Receive inbound updates or comments from external sources through APIs or webhooks.

This allows cross-team collaboration, even with users who are not logged into Pega, thereby enabling use cases such as:

• Customer service agents responding to social media complaints.

• Loan reviewers getting alerts through enterprise chat tools.

Why Include:

While not standard out-of-the-box, these are commonly implemented in enterprise solutions and may be mentioned in design scenario questions or as LSA project discussions.

3. Circumstance Rules – Additional Types

Most Pega learners are familiar with Property-Based Circumstancing, but to ensure a well-rounded understanding, the following types should be briefly introduced:

a. Date-Based Circumstancing:

• Allows a rule to become active only on or after a specified date or within a specific time range.

• Commonly used for:

  • Time-sensitive pricing policies

  • Deadline-driven business rules

b. Template Circumstancing:

• Used when the circumstancing logic relies on multiple properties.

• Requires:

  1. A template rule with property placeholders.

  2. One or more definition rules specifying actual values.

Example:

A loan eligibility decision rule might use a template circumstancing rule with properties like .LoanType and .CustomerSegment.

Exam Note:

LSA exams often test scenario-based rule resolution involving multiple circumstancing types. A solid grasp of this topic is critical for resolving which rule will be executed in different contexts.

4. Queue Processor – Standard vs Dedicated

When covering asynchronous processing in Pega using Queue Processors, it's crucial to distinguish between the two types:

Standard Queue Processor:

• Managed by the system.

• Shared across multiple operations.

• Configured via System Runtime Context.

• Typically used for generic background tasks such as audit logging or notification processing.

Dedicated Queue Processor:

• Created and configured by the application developer.

• Offers fine-grained control, such as:

  • Threading model (number of threads)

  • Delay settings

  • Error handling policies

• Best for business-critical or performance-sensitive tasks like:

  • Transaction posting

  • Fraud check processing

  • Integration queueing

Design Tip:

• Use Standard when tasks are lightweight and non-blocking.

• Use Dedicated when tasks require specific isolation, performance tuning, or error recovery control.