Free PEGACPLSA23V1 Practice Test Questions and Answers (2026)

The configured Content Security Policy (CSP) includes the directive img-src 'self' data: blob:. This directive instructs the browser to only load images from the application's own origin ('self'), as data: URIs, or as blob: URIs. The attempt to load an image from an external domain, https://malicious.com, violates this policy. A compliant browser enforces the CSP by blocking the request to the unauthorized domain. As a result, the image will fail to load, and the browser will typically log a security violation error in its developer console.

B: The browser blocks the network request entirely; it does not load the resource and then decide against displaying it.

C: A compliant browser's function is to enforce the CSP, not ignore it. Ignoring the policy would render it useless.

D: The image will not load because its source, https://malicious.com, is not on the whitelist defined by the img-src directive.

1. Pega Platform™ Documentation

"Content security policies": This document outlines that a CSP adds a layer of protection to mitigate attacks like cross-site scripting by specifying the domains that the browser should consider valid sources for resources. The browser is responsible for enforcing this policy.

2. Pega Platform™ Documentation

"Content security policy management": This section details the configuration of CSP directives

including img-src. It explains that these directives create a whitelist of allowed sources

and any resource from a non-whitelisted source will be blocked by the browser.

3. Pega Platform™ Documentation

"Security Checklist": The Pega security checklist emphasizes implementing a strict Content Security Policy as a critical measure to secure the application

confirming that policies are meant to be enforced to prevent loading of untrusted assets.

This scenario describes a classic cascading or dependent data relationship. The best practice in Pega is to use separate, dedicated data pages for each distinct data entity. A list-structure data page should be created to populate the top-level Categories. A second, parameterized list-structure data page should be created for Sub-categories. This Sub-category data page accepts the selected Category ID as a parameter to filter and retrieve only the relevant sub-categories from the database. This approach is modular, reusable, and aligns with Pega's data virtualization principles for optimal performance and maintainability.

A: Using a single, complex data page for both entities violates the single responsibility principle, making it less reusable, harder to maintain, and less performant than two dedicated data pages.

B: This option is incomplete as it fails to specify a data page for loading the initial Category list, which is a critical first step and a Pega best practice.

D: This option only addresses retrieving data after a Sub-category is selected. It completely ignores the primary requirement of how to populate the Category and Sub-category selection lists.

1. Pega Documentation

"Configuring a cascading control": This document explicitly outlines the correct pattern. It states

"To configure a cascading control

you create two controls and source them with two separate data pages. The first data page retrieves a list of values for the first control. The second data page is parameterized to retrieve a filtered list of values for the second control based on the value of the first control." This directly supports option C.

Source: Pega Community / Pega Platform 8.8 Documentation

"Configuring a cascading control".

2. Pega Documentation

"Creating a data page": The documentation on creating data pages emphasizes their role in separating data retrieval logic from the UI. It details the use of parameters to make data pages context-aware

which is the core mechanism for the Sub-category data page.

Source: Pega Community / Pega Platform 8.8 Documentation

"Creating a data page"

Section: "Data page parameters".

3. Pega Academy

Lead System Architect (LSA) Courseware

"Data Modeling" Module: The LSA curriculum stresses the importance of creating a clean

logical

and reusable data model. The principle of creating distinct data pages for distinct business objects (like Category and Sub-category) is a fundamental concept for building scalable and maintainable applications.

Source: Pega Academy

Lead System Architect 8.8

"Data and Integration" Mission

"Data Pages" Module.

Relevant records are a design-time feature specifically created to enhance the low-code experience in App Studio. Their primary purpose is to allow Lead System Architects (LSAs) to curate a list of pertinent rules for citizen developers. This curation has two main benefits. First, it filters the options presented in App Studio, preventing developers from being overwhelmed by irrelevant technical rules and reducing search time (Benefit B). Second, it enables LSAs to deliberately "promote" specific, pre-approved rules from built-on or framework applications for reuse in the current application layer, ensuring consistency and leveraging enterprise assets (Benefit C).

A: This is incorrect. Relevant records are a design-time feature for App Studio. They do not control the run-time availability or performance of rules; that is managed by rule availability settings (e.g., Available, Withdrawn).

D: This is incorrect. Relevant records apply to configurable rules (metadata such as properties, views, and flows), not transactional data or case instances. You cannot "promote" a data instance using this feature.

1. Pega Platform™ 23.1 Documentation

"Marking records as relevant": This document states

"To provide a record to application developers in App Studio

you mark the record as relevant... You can mark a record that is defined in a built-on application as relevant to make it available in your current application." This directly supports promoting rules from built-on applications for reuse (Option C).

2. Pega Platform™ 23.1 Documentation

"Relevant records for citizen developers": This source explains

"As a lead system architect (LSA)

you can curate records for citizen developers in App Studio to streamline the user experience and accelerate application development." This directly supports the concept of regulating design-time prompting and filtering to simplify the developer experience (Option B).

3. Pega Academy

"Low-Code App Builder" Module

"Relevant Records" Topic: Courseware explains that relevant records are used to expose rules to developers in App Studio

filtering out records that are not meaningful in the context of a case type. This prevents low-code developers from having to navigate through long lists of inapplicable rules. This supports the core idea of Option B.

The most effective and robust approach for managing limited resources subject to concurrent requests is to leverage the Pega Platform's built-in locking mechanism. This pattern involves representing the resource as a specific instance (either a data object or a case). By acquiring a lock on this instance when a user attempts to reserve it (a pessimistic locking strategy), the platform automatically prevents other sessions from accessing and modifying the same resource simultaneously. This ensures data integrity and prevents over-commitment of the limited resource, directly addressing the core challenge of the design pattern.

B: Using custom flags to manage locks is a manual, less reliable approach compared to the platform's robust, built-in locking services, increasing the risk of race conditions.

C: Locking a case instance that represents the request does not solve the problem, as it fails to lock the underlying shared resource, allowing multiple requests for it.

D: Circumstancing is a rule specialization technique used to select different rule versions based on property values; it is irrelevant to managing real-time concurrency and resource locking.

1. Pega Community

"Design patterns for limited availability": This document explicitly describes the pattern for scenarios like booking seats or appointments. It states

"The most common approach to managing limited availability is to use a pessimistic locking strategy. When a user selects a resource

the system locks the resource to prevent other users from selecting it." This directly supports locking the resource instance.

2. Pega Platform 8.8 Help

"Case locking": This documentation details the pessimistic locking mechanism. It explains

"With pessimistic locking

the first user who opens a case instance locks it. No other user can edit the case until the first user releases the lock." This is the mechanism used on the resource instance as described in option A.

3. Pega Platform 8.8 Help

"Managing locked objects": This guide describes how the system handles locks

reinforcing that locking an object is the standard Pega method for ensuring that only one operator can update an object at a time

which is the essence of managing concurrency.

A Job Scheduler in Pega is designed for high-performance, recurring background tasks. Its key features are centered on efficiency and resilience.

It can run tasks in parallel (D) by distributing the workload across multiple nodes in a cluster. This is a primary feature for achieving high throughput, which is essential for the e-commerce scenario described.

For resilience, a robust background processing system must handle transient failures. Job Schedulers achieve this by running an activity that can contain error handling and retry logic (A). While the Queue Processor rule has more declarative retry settings, implementing a retry mechanism is a typical and necessary feature for any solution using a Job Scheduler for critical tasks.

B. It can run tasks in a specific order. The primary design of a Job Scheduler is for parallel processing to maximize throughput, which is inherently not sequential. Enforcing a specific order is not a typical feature.

C. It can automatically commit the data updates. Data commits are managed by the underlying Pega Platform transaction model for all processing, not a specific feature of the Job Scheduler rule itself.

1. Parallel Processing (Option D):

Pegasystems. (2023). Asynchronous processing. Pega Community. "Job Scheduler is a background server process that runs an activity at a pre-configured time... For high-volume and heavily recurring tasks

you can configure a Job Scheduler to run on multiple nodes to support parallel processing."

Pegasystems. (2023). Processing a list of items with a job scheduler. Pega Community. "To enable parallel processing

you can associate a job scheduler with a node type. Pega Platform queues the items for the job scheduler and you can process the items in parallel on all the nodes that are assigned to a specific node type."

2. Retry Failed Tasks (Option A):

Pegasystems. (2023). Asynchronous processing. Pega Community. This document contrasts Job Schedulers with Queue Processors

noting Queue Processors are ideal for "a task that you can retry if it fails." This implies that handling failures and retries is a core concept in asynchronous processing

and the Job Scheduler

as a tool for this

facilitates such logic within its activity

making it a typical feature of the overall solution. The activity run by the Job Scheduler is responsible for implementing the retry logic if needed.

The most precise and best way to implement this requirement in Pega is by using its Role-Based Access Control (RBAC) model. Option C provides the specific, actionable steps for this implementation: creating a dedicated access role (HRApp:SeniorExec), assigning it only to the authorized senior executive users, and then granting the necessary privileges to access the sensitive reports directly to that role. This approach ensures a clear, maintainable, and secure design by directly linking a user's business function to their system permissions, which is a core Pega security best practice.

A: This option is too general. While correct that an RBAC system is needed, option C describes the specific Pega implementation of that system, making it a more precise and superior answer.

B: The Access Control Check is a static analysis tool used to audit and identify potential security vulnerabilities in rules. It does not implement or enforce access control policies.

D: Data masking is a technique to obscure sensitive data fields within a report or UI. It does not control or restrict access to the entire report object itself.

1. Pega Platform™ 8.8 Help - "Creating an access role": This document outlines the process of creating an Access Role object

such as HRApp:SeniorExec

to define a set of permissions for a group of users with a common business function. This directly supports the action described in option C.

2. Pega Platform™ 8.8 Help - "Granting privileges to an access role": This guide explains how to use an Access of Role to Object (ARO) rule to grant specific permissions (e.g.

view

run) for a class

such as the one containing the reports

to a specific access role. This is the mechanism for the second part of option C.

3. Pega Platform™ 8.8 Help - "Authorization in Pega Platform": This document describes Pega's authorization models

emphasizing RBAC as the primary model. It states

"In a role-based access control model

privileges are grouped into roles that are assigned to users

" validating the approach in option C as the standard method.

The most effective and standard Pega solution is to use Role-Based Access Control (RBAC). This involves creating an Access Role (HRApp:SalaryReview) that contains the specific permission to open the SalaryReview case type (an Access of Role to Object rule). This role is then assigned to the access groups for the intended users (HRApp:HRStaff and HRApp:Managers). This approach directly maps the business requirement of granting access based on user function to Pega's core security model, ensuring a clear, maintainable, and secure design.

B: Client-based access control (CBAC) is a specialized feature for managing data privacy based on customer consent, not for controlling application access based on an employee's role.

C: Attribute-based access control (ABAC) is for more complex, dynamic authorization. For a static requirement based on user roles, RBAC (Option A) is the simpler and more direct solution.

D: Using an Access Deny policy is not a best practice. Pega security follows a "default deny" principle, where access should be explicitly granted rather than explicitly denied.

1. For Correct Answer (A): Pegasystems. (2023). Security checklist for Pega Platform. Pega Documentation. "Configure authorization by using role-based access control (RBAC) to define the actions that users can perform... An access group references one or more access roles." This confirms that combining access groups and roles is the standard RBAC method.

2. For Correct Answer (A): Pegasystems. (2023). Creating an access role. Pega Documentation. "You create access roles to define the access capabilities that are granted to a user." This supports the creation of a specific role for SalaryReview permissions.

3. For Incorrect Option (C): Pegasystems. (2023). Comparing role-based and attribute-based access control. Pega Documentation. "RBAC is easier to implement and is sufficient for applications with a limited number of roles... ABAC is better suited for more complex security requirements." This justifies choosing RBAC (A) over ABAC (C) for this straightforward scenario.

4. For Incorrect Option (D): Pegasystems. (2023). Access Deny rules. Pega Documentation. "As a best practice

use Access Deny rules only when an Access of Role to Object or Access Deny setting cannot produce the desired security outcome." This establishes that Access Deny is a secondary mechanism

not the primary solution.

5. For Incorrect Option (B): Pegasystems. (2023). Implementing Client-Based Access Control. Pega Documentation. "Client-based access control (CBAC) allows you to track and process requests that are related to personal customer data." This confirms CBAC's specific purpose is data privacy

not general case type access.

The most effective corrective actions an LSA can recommend to address performance degradation from high data volume are application-centric. Archiving and purging resolved cases (B) directly reduces the size of the active dataset in transactional tables, which significantly improves query performance and processing times. This is a standard Pega best practice. Concurrently, ensuring critical tables are properly indexed (D) is essential. As data volume grows, unindexed or poorly indexed queries become a primary bottleneck. An LSA uses tools like the Performance Analyzer (PAL) to identify slow queries and creates database indexes on properties to optimize data retrieval for reports, UI displays, and background processing.

A. Implement horizontal and vertical database partitioning strategies and replication to distribute the load effectively. This is a database infrastructure-level activity, typically managed by a Database Administrator (DBA), not a direct application-level change implemented by an LSA.

C. Schedule regular database defragmentation sessions in collaboration with the Database Administrator. While beneficial for database health, defragmentation is a routine maintenance task for a DBA and is less impactful for this specific problem than directly reducing and optimizing access to the data.

1. Archiving and Purging (Supports Option B): Pega Academy

Lead System Architect (Pega Infinity '23) course

"Data Management" module. This module details the process of using the case archival and purge wizard to move resolved case data from primary transactional tables to an archive

directly addressing performance issues caused by large data volumes.

2. Database Indexing (Supports Option D): Pega Community

"Creating a custom index." This document explains how LSAs can create single or composite indexes on properties directly from the property rule form in Dev Studio to improve the performance of database queries

especially for reports.

3. Performance Best Practices (Supports B & D): Pega Community

"Performance guidance for Pega Platform." This guide emphasizes that managing data growth through purging and archiving

and ensuring proper database indexing

are two fundamental strategies for maintaining application performance. It distinguishes these application-level tasks from underlying database administration.

4. LSA Responsibilities (General Support): Pega Academy

Lead System Architect (Pega Infinity '23) course

"Pega's Class Structure" module

"Property Optimization" lesson. This lesson describes the LSA's responsibility to optimize properties by creating indexes to improve report and query performance

reinforcing that this is a core LSA task.

This scenario requires a two-part solution: a bulk export of historical data and a near real-time mechanism for new data.

Option B is ideal because it uses a BIX (Business Intelligence Exchange) extract rule for the historical data. BIX is Pega's purpose-built, high-performance feature for extracting large volumes of data for external reporting and data warehouses. For ongoing cases, triggering a REST post upon resolution is a standard pattern.

Option C is also an ideal, modern solution. It uses a data flow to read historical cases and a Queue Processor to handle the REST API calls asynchronously. This is a scalable and resilient pattern for bulk background processing. Reusing the same Queue Processor for newly resolved cases is efficient and meets the near real-time requirement without impacting user performance.

A: Performing a synchronous REST call within a data flow for a large historical dataset is inefficient, not scalable, and risks timeouts, making it a poor design choice.

D: Using a utility with Obj-Browse to read three years of case data is highly inefficient and can cause severe performance and memory issues. It is not a best practice for large datasets.

1. BIX/Extract Rule (for Option B): Pega Platform™ 8.8 Help

"Creating and running a BIX extract." This document describes using BIX for extracting data from Pega applications for use in external systems

which is the exact requirement for the historical data. It notes BIX is designed for high-throughput data extraction.

2. Data Flows and Queue Processors (for Option C): Pega Platform™ 8.8 Help

"Data flows." This source explains that data flows are the primary mechanism for processing large amounts of data in the background. The section "Data flow processing" details how data flows can be used for batch processing and can output to various destinations

including activities that queue to a Queue Processor.

3. Asynchronous Processing with Queue Processors (for Option C): Pega Platform™ 8.8 Help

"Queue Processor rules." This document explains that Queue Processors provide scalable

asynchronous processing. Using a Queue Processor to call a REST service decouples the main processing thread (either the data flow or the user's case processing) from the integration

improving performance and reliability

which is ideal for both the bulk and near real-time requirements.

4. Inefficiency of Obj-Browse for Bulk Operations (for Option D): Pega Lead System Architect (LSA) courseware and Pega Platform™ 8.8 Help on "Performance guidelines for activities" consistently advise against using Obj-Browse for large datasets due to its impact on memory and database performance. Report definitions or data flows are the recommended alternatives.

The CASE statement is the standard SQL function for handling multiple conditions. This option correctly implements the specified logic for all three customer categories. The first WHEN clause handles the 'Silver' category for amounts less than 500. The second WHEN clause uses the BETWEEN operator, which is inclusive, to correctly identify the 'Gold' category from 500 to 2000. The ELSE clause correctly assigns all remaining customers (those with total bookings over 2000) to the 'Platinum' category. This syntax is precisely what is used when defining a function alias in a Pega Report Definition.

B: The logic is fundamentally flawed. It only checks for a single value (= 2000) and incorrectly categorizes all other customers as 'Gold', completely ignoring the 'Silver' category and the specified ranges.

C: While nested IF functions exist in some SQL dialects, the standard and Pega-recommended approach for multi-level conditional logic is the CASE statement. Option A is more portable and idiomatic within Pega.

D: The SELECT keyword is part of a full SQL query, not the function alias expression itself. In Pega, you define only the expression (the CASE statement) which is then embedded into the report's generated SELECT query.

1. Pegasystems Documentation - "Creating function aliases in reports": This document explains how to create custom SQL expressions for use in Report Definitions. The examples provided for conditional logic utilize the CASE WHEN ... THEN ... ELSE ... END syntax

confirming it as the standard Pega approach.

Reference: Pega Platform > Decisioning and reporting > Reporting > Creating function aliases in reports.

2. Pegasystems Documentation - "Function alias form — Completing the Definition tab": This guide details the configuration of a function alias rule. It specifies that the "Function" field on the Definition tab should contain the SQL expression pattern

such as a CASE statement

without including keywords like SELECT.

Reference: Pega Platform > Dev Studio > Records > Technical > Function Alias > Function alias form — Completing the Definition tab.

To methodically troubleshoot sudden database-related delays, a Lead System Architect should focus on isolating the root cause without exacerbating the issue.

Option A is a direct diagnostic step. By reducing the query-time alert threshold, the system becomes more sensitive to long-running database queries. This helps capture performance data on queries that are slower than desired but might not have crossed the default, higher threshold, enabling precise identification of problematic SQL.

Option C represents a sound analytical methodology. Correlating user-reported delays with peak database usage times allows the architect to focus their investigation of logs and alerts (like those generated from option A) on the most relevant time windows, making the troubleshooting process more efficient and targeted.

B: Raising the blob-size alert threshold would make the system less likely to report large case instances, effectively hiding the very problem you might be looking for.

D: Writing Pega logs to the database would add extra load to a database server that is already suspected of being a performance bottleneck, likely worsening the user-reported delays.

1. For A & C: Pegasystems. (2023). Investigating performance issues. Pega Community. This article outlines a methodology that includes analyzing alerts during periods of poor performance. It states

"Check the PegaRULES log and the PegaALERT log for the time when the performance was poor... The PegaALERT log contains specific information about the performance of the system." Lowering thresholds is a standard technique to generate more granular alerts for analysis.

Reference: Pegasystems Documentation

"Investigating performance issues

" section on "Checking logs."

2. For A: Pegasystems. (2023). List of performance-related system settings. Pega Community. The documentation for the alerts/database/queryTimeThreshold setting explicitly describes its purpose for identifying long-running queries. Lowering this value is the correct action to increase diagnostic sensitivity.

Reference: Pegasystems Documentation

"List of performance-related system settings

" entry for alerts/database/queryTimeThreshold.

3. For B: Pegasystems. (2023). PEGA0025 alert: Blob size is greater than threshold. Pega Community. This documentation explains that the alert is triggered when the blob size exceeds the configured threshold. To detect more potential issues

one would lower

not raise

this threshold.

Reference: Pegasystems Documentation

"PEGA0025 alert: Blob size is greater than threshold."

4. For D: Pegasystems. (2023). Managing logs. Pega Community. Pega best practices recommend writing logs to files rather than the database in production environments to avoid performance overhead on the database. The documentation notes that logging to the database can impact performance.

Reference: Pegasystems Documentation

"Managing logs

" section on "Log files."

The primary purpose of an Attribute-Based Access Control (ABAC) "Discover" policy is to determine whether a user can see the existence of a data instance, such as a case, and view a limited set of its details in lists, searches, and reports. This is specifically designed for scenarios where users, like managers or supervisors, need high-level visibility or "insights" into cases for which they do not have full read permissions. It allows them to be aware of the case and see essential, non-sensitive information (e.g., Case ID, status) without accessing the full case details.

A: The "Discover" policy is intended to show limited, non-sensitive information, not to reveal sensitive details, which would typically require a "Read" or "PropertyRead" policy.

B: The purpose is to grant limited visibility to specific users, not to restrict access for all users. It is a permissive policy for a defined group.

C: This policy controls visibility of individual case instances within a report or list, not access to the entire dashboard or user portal itself.

1. Pegasystems - Pega Platform Help: Creating an access control policy. This document explicitly defines the "Discover" policy type. It states

"A Discover policy determines whether a user can see the existence of a rule or data instance and view limited details in lists

searches

and reports." This directly supports the function described in the correct answer.

2. Pegasystems - Pega Platform Help: Access control policies. This guide provides an overview of access control policies

including ABAC. It explains that policies are used to define granular access based on attributes

and the "Discover" type is used for visibility in reports and searches when read access is not granted.

3. Pegasystems - Pega Academy Courseware: Lead System Architect (LSA) Pega Architecture 8.8 - Module: Implementing attribute-based access control. This course details the different ABAC policy types. It clarifies that the "Discover" policy allows users to see records in a list view or report but prevents them from opening the record

which aligns with providing "insights" without "full read access."

The core principle for mitigating a single point of failure (SPOF) in a high-availability (HA) architecture is implementing a reliable failover mechanism. This ensures that if a primary Pega node or component fails, a redundant, standby node automatically and seamlessly takes over its processing responsibilities. This process maintains service continuity and prevents data loss, directly addressing the financial institution's requirement for an "always-on" platform. While failure detection is necessary, the failover action itself is the primary mitigation against the downtime caused by a SPOF.

A: Regular data backups are a component of a Disaster Recovery (DR) strategy, which is distinct from High Availability. DR focuses on recovering from catastrophic data loss, not preventing immediate service interruption.

B: Establishing a single administrative group creates a new single point of failure from an operational and security perspective, directly contradicting the goal of avoiding common cause failures.

D: Detecting failures is a critical prerequisite for initiating a failover, but detection alone does not mitigate the failure. The failover process is the actual countermeasure that ensures service continuity.

1. Pega Platform™ High Availability Administration Guide: In the "High availability overview" section

the guide defines high availability through features like redundancy and failover. It states

"Failover is the process of switching to a redundant or standby system component upon the failure or abnormal termination of the previously active component." This directly supports that failover is the key mechanism for handling component failure.

2. Pega Academy - Lead System Architect (8.7) Module: "Ensuring High Availability": This courseware emphasizes that a high-availability architecture relies on eliminating single points of failure through redundancy and automatic failover. It distinguishes HA (maintaining uptime) from Disaster Recovery (recovering from site-wide failure)

clarifying why backups (Option A) are not the primary HA principle.

3. Pega Community - Article: "High availability": This article outlines the key features of a Pega HA configuration

listing "Redundancy

Failover

and Monitoring." It clarifies that failover is the active process that ensures continuity when a redundant component is needed

positioning it as the central principle for mitigating a SPOF. Monitoring (Option D) is presented as a supporting feature that enables failover.

The Library in App Studio serves as a centralized repository for reusable assets, significantly accelerating application development. Its primary advantages are enabling developers to discover and add pre-built components (such as UI templates, data objects, and utilities) to their current application, thereby quickly enabling new features. Strategically, it promotes an enterprise-wide reuse strategy by making assets from all built-on applications available, ensuring consistency, reducing redundant work, and optimizing the overall development process across the Pega ecosystem.

A. Update the existing components to make it more specific to the current application. This is incorrect. The purpose of a library is to promote reuse of generic components, not to specialize them for a single application, which defeats the purpose of reusability.

B. Perform create, read, update, and delete operations on the library components. This is too generic and misleading. While you manage components, the core advantage is not the CRUD capability itself, but the ability to browse and add reusable assets to an application.

1. Pega Platform™ Documentation - "The Library tab in App Studio": This document states

"The Library tab in App Studio provides a central repository for all the reusable assets

or components

that are available in your application. By reusing components

you can speed up application development and ensure consistency... From the Library

you can add components to your application to enable new features..." This directly supports options C and D.

2. Pega Platform™ Documentation - "Creating reusable components": This guide explains that components intended for the Library should be built for reuse. It emphasizes

"When you create a component

you package a set of rules that you can then reuse in case types across your application." This reinforces the concept of reuse (Option D) and adding features (Option C)

while implicitly contradicting the idea of specializing a library component for one-off use (Option A).

3. Pega Academy - Lead System Architect (LSA) Mission - "Enterprise architecture" module: This courseware emphasizes the LSA's role in establishing an enterprise layer of reusable assets. The Library is presented as a key tool for developers to consume these assets

which aligns with optimizing application creation by reusing assets from the entire Pega ecosystem (Option D).

A function alias is the most appropriate and efficient Pega Platform feature for this requirement. It allows a developer to create a reusable alias for a database function, which can then be used directly within a Report Definition. To meet the requirement, a function alias can be created to calculate the difference between the current date and the customer's start date. This alias can then be used in a report column to categorize the customer's tenure into the specified time buckets (e.g., using a CASE statement within the function). The report can then be summarized by this calculated column to display the count of customers in each category, directly fulfilling the business need in a declarative, maintainable, and performant way.

B. Use a correlated subreport: A subreport is used to combine data from different classes or for complex joins, which is not required here as all data exists within the same customer context.

C. Use a Rule-Obj-ListView with a custom getContent activity: Rule-Obj-ListView is a deprecated rule type. Modern Pega applications use Report Definitions. Relying on custom activities for reporting logic is against best practices.

D. Use a Connect-SQL rule: This involves writing raw SQL, which bypasses the declarative features, security, and optimization benefits of the Pega reporting framework. It is unnecessary for this type of data bucketing.

1. Using function aliases in reports

Pega Platform 8.8 Documentation: "You can use function aliases in report definitions to provide more flexible reporting options. For example

you can use function aliases to apply an SQL function to a column of data to format or calculate the results... This approach is useful for creating custom calculations or formatting that is not available through the standard reporting features." This directly supports using a function alias for the calculation and categorization required.

2. Creating a function alias

Pega Platform 8.8 Documentation: This document details the process of creating a function alias

noting its purpose is to "make it easier for application developers to use functions in their reports." This aligns with creating a specific function for the tenure calculation.

3. About Report Definition rules

Pega Platform 8.8 Documentation: "Report definition rules generate HTML and SQL that is executed to retrieve and format the data for the report. Report definitions are the preferred rule type for creating reports in Pega Platform." This reference establishes Report Definitions as the standard tool

making the use of deprecated ListViews (Option C) or external Connect-SQL (Option D) incorrect for this standard requirement.

4. Grouping results in a report

Pega Platform 8.8 Documentation: "To better visualize and analyze your data

you can group results in a report... For example

you can group a list of employees by their office location to see how many employees work in each office." This supports the final step of summarizing the data by the calculated category column created with the function alias.