Explanation:

B. Add the access groups to the application record :
When an access group is referenced in the Application record, and the application is included in the Product rule, the system automatically includes all referenced access groups during export. This is a best practice, as it simplifies deployment by linking access groups directly to the app configuration. It avoids manual maintenance of access group instances in your RAP and ensures proper linkage to the application on import.

Reference:
Pega Docs – Associating access groups with application records

C. Add the access group to the Product record in the Individual instances to include section:
The "Individual instances to include" section in a Product rule lets you manually select data instances, such as Data-Admin-Operator-AccessGroup, for export. This is often used for access groups not automatically included through an application or ruleset. You can explicitly add specific access groups here by class and name, which ensures they're part of the exported RAP.

Reference:
Pega Academy – Creating Product rules for deployment

A. Export the access groups using the Access Manager:
Access Manager is used for viewing and editing role-based access but not for exporting configurations. It cannot be used to directly include access groups into a Product rule. It's a runtime tool, not a packaging or deployment feature. Hence, this method does not apply to Product rule inclusion.

Reference:
Pega Docs – Using Access Manager

D. Associate the access groups with a ruleset included in the application:
Access groups are not versioned rules, and they are not stored in rulesets. They are Data instances of class Data-Admin-Operator-AccessGroup, which means associating them with a ruleset has no direct effect. Even if a ruleset is included in the application, it will not cause unrelated access groups to be exported unless manually included.

Reference:
Pega Support – Access groups are data instances and not stored in rulesets

Final Answer:
B. Add the access groups to the application record
C. Add the access group to the Product record in the Individual instances to include section

Explanation:

C. Production:
A Production ruleset is specifically designed to contain business-editable rules. It is marked as editable only in production environments, allowing business users to safely manage and update logic (like discount codes or approval thresholds) through the user portal. This enables organizations to quickly adapt to changing business needs without developer involvement. Delegating the Decision Table into a production ruleset ensures the rule is both editable and isolated from the core application logic, reducing risk and simplifying updates.

Reference:
Pega Docs – Delegating rules to business users Pega Academy – Production Rulesets

A. Organization;
The Organization ruleset is used for shared, reusable assets across multiple applications within the organization — such as validation logic, templates, or utility functions. It is not intended for rule delegation because it’s typically managed by developers and locked in production. Placing a decision table here does not allow business user updates, which defeats the purpose of delegation.

B. Integration :
The Integration ruleset contains rules that enable the application to connect to external systems, such as connectors, service rules, and data mappings. It is highly technical in nature and not suitable for business-managed logic like vendor discount codes. Delegating a decision table from this ruleset would be both inappropriate and insecure.

D. Application:
The Application ruleset holds the main application logic created during development. In production, it is typically locked to prevent accidental changes that could break functionality. Because of this, rules in the application ruleset cannot be edited or delegated to end users without unlocking the ruleset, which is strongly discouraged in production environments

. Final Answer:
C. Production – because it is the only ruleset type meant for delegation to non-developers in a safe and controlled way.

Explanation:

A. Configure a class join on the Fulfillment report definition to join operator information to each case.
A class join in a report definition allows you to pull related data from another class (e.g., Data-Admin-Operator-ID) into the report. In this case, if the Ship stage (class: MyCo-Orders-Work-Ship) contains a reference to the user ID (such as .PackagedBy or similar), a class join to the operator table would allow access to other operator details like full name, email, etc. This is a common and efficient method to include related operator data in reporting.

Reference:
Pega Docs – Report Definition joins

B. Add the user ID to the Fulfillment report definition as a parameter.
This option is incorrect because parameters in report definitions are used to filter or constrain the report at runtime, not to display fields in the report results. You cannot populate the user ID of the packaging employee simply by passing it as a parameter unless it's already known externally. This does not satisfy the requirement to retrieve and list the user ID within the report logic itself.

C. Specify both classes on the Pages & Classes tab on the Fulfillment report definition.
The Pages & Classes tab is mainly relevant in data transforms or activities, not report definitions. In report definitions, joins and associations define how data is fetched. This tab is not used in report definitions to combine data from multiple classes. Therefore, specifying classes here will have no impact on the report’s ability to retrieve user ID from another class.

D. Use an association rule to join operator information to each case to populate the Fulfillment report.
An association rule is a reusable join between classes — for example, linking .PackagedBy in the case class to pyUserIdentifier in the Data-Admin-Operator-ID class. Once defined, the association can be used in multiple report definitions without redefining the join logic each time. This not only improves modularity and reusability but also simplifies report configuration by referencing the association instead of manual class joins.

Reference:
Pega Academy – Using Associations in Reports

Final Answers:
A. Configure a class join
D. Use an association rule

Explanation:

A. Configure the When condition "IsCurrentStageTesting" to allow users to view an attachment if the rule returns true.
In Pega, access to attachment categories can be conditionally controlled using a When rule, which determines whether a user is allowed to perform a specific action (view/edit/delete) on an attachment based on the case context. For example, by using a When rule like IsCurrentStageTesting, you can restrict access to attachments to only when the case is in a particular stage. This provides context-aware, dynamic control over attachment access — an essential part of fine-grained security.

Reference:
Pega Docs – Controlling access to attachments using attachment categories

B. Configure a Visible when condition called "IsDocumentPrivate" to allow users to view an attachment if the rule returns false.
This option is incorrect because "Visible When" conditions are primarily used in UI rules (like sections or layouts) to control visual display of fields or components — not to control security or access rights to attachments. Even if an attachment is hidden via a UI rule, a user could still access it directly via a URL or API, making it an insecure approach. For security, Pega recommends using attachment category settings with When rules or privileges.

C. Configure the privilege "DeleteOwn" and assign it to a user so that a user can delete their own attachments.
Pega supports assigning privileges to control actions on attachments. The "DeleteOwn" privilege allows users to delete only the attachments they themselves created, while preventing them from deleting attachments added by others. This is a least privilege principle and a best practice in secure access management. The privilege must be configured in the Attachment Category rule and mapped to the appropriate access role.

Reference:
Pega Docs – Setting privileges for attachment categories

D. Configure Client-based access control on the class where the attachment category exists to restrict access to the attachment.
Client-based access control (CBAC) in Pega is used primarily for data masking or redaction of personally identifiable information (PII) and sensitive attributes at runtime. It’s not designed for managing access to attachment categories or file-level permissions. To control access to attachments, Pega provides dedicated mechanisms via the Attachment Category rule configuration, which supports When conditions and privileges — not CBAC.

Reference:
Pega Docs – Attribute-based access control (ABAC) and CBAC

Final Answers:
A. Configure the When condition "IsCurrentStageTesting"
C. Configure the privilege "DeleteOwn"

Explanation:

A. Services require a REST connector to function:
A REST connector is used when Pega acts as a client, calling an external service. However, services in Pega are for receiving requests (inbound), where Pega acts as the server. Therefore, a REST connector is not needed for a service to function. REST connectors are only used when integrating outbound, not for exposing services via Pega.

Reference:
Pega:Services vs. Connectors

B. Services return all data in XML format:
This is incorrect. Pega services support multiple data formats, including XML, JSON, CSV, and plain text. The format depends on the service type (e.g., REST, SOAP) and how it’s configured. For example, REST services usually return JSON, while SOAP services often use XML. The idea that all services return only XML is outdated and incorrect in modern Pega development.

Reference:
Pega: Creating REST Services

C. Services may process outbound requests:
Services in Pega are designed for inbound communication only — that is, they allow external systems to call into Pega. Outbound requests (where Pega initiates the call) are handled by connectors, not services. So, the statement is false: services cannot process outbound requests.

Reference:
Pega: Inbound vs Outbound Integration

D. Services may use a listener that runs in the background:
Correct. Some types of services — like file services, email services, or JMS services — require listeners. A listener is a background process that watches for events (e.g., incoming files or emails) and triggers the corresponding service rule. This is common in asynchronous integration scenarios. For example: An email listener monitors an inbox and forwards incoming messages to an email service rule. A file listener watches a directory for files to process.

Reference:
Pega: Listeners Overview

Final Answer:
D. Services may use a listener that runs in the background.

explanation

A. Call the function pega.web.api.doAction() :
The pega.web.api.doAction() function is a JavaScript API method provided by Pega Web Mashup. It allows the web host page to perform specific actions on the embedded Pega application. This includes actions like creating a new case, opening an assignment, or setting data. It is one of the primary ways to pass instructions and data from the web page to the Pega app. You can use it alongside parameters to control behavior dynamically, making it a standard method of communication from host to mashup.

Reference:
Pega Web Mashup JavaScript API

B. Call a Pega API function from the host server:
While you can interact with Pega’s REST APIs for data or case management, this is not considered part of Web Mashup integration. Web Mashups are client-side embeds; calling an API from a host server would require a separate integration layer and would not qualify as a Web Mashup mechanism. Furthermore, using Pega API from the server assumes authenticated, secure RESTful integration, which is not related to mashup-based client-side data flow.

Reference:
Pega REST API documentation

C. Use REST methods to call Pega microservices:
Using REST methods to communicate with Pega microservices is valid for traditional integration scenarios, but not a mashup-specific technique. Mashups work through HTML iframe embeds and JavaScript APIs, not HTTP REST endpoints. While it's possible to call REST APIs in parallel, REST is not a mechanism to pass data between the mashup and host page directly. This option is incorrect in the context of Web Mashup communication.

Reference:
When to Use Pega APIs vs. Mashup

D. Use the attribute data-pega-event-onpagedata:
The data-pega-event-onpagedata attribute is a special mashup parameter that allows developers to send data from the host page to the Pega Web Mashup. This attribute defines the name of a JavaScript event that the mashup listens for. When triggered, it passes the data payload from the host page into the embedded Pega app, making it highly effective for dynamic, bidirectional communication. This is an official and supported method for sending page-level data into a mashup.

Reference:
Pega Web Mashup Attributes

Final Answer:
A. Call the function pega.web.api.doAction()
D. Use the attribute data-pega-event-onpagedata

explanation

A. Create a new ruleset version for the base application:
Creating a new ruleset version for the base application allows rule updates, but it doesn't solve the problem of multiple teams working simultaneously. This would mean all teams are working in the same ruleset, potentially overwriting each other's rules and causing merge conflicts. Ruleset versions are used for versioning and packaging, not isolating parallel development work. This option doesn’t prevent collisions between teams and isn’t recommended for collaborative development.

Reference:
Pega Platform Dev Studio Guide – Ruleset Versioning https://docs.pega.com

B. Create branches in each team's application:
Creating branches is the standard and recommended way in Pega to allow parallel development. Each team can work on its own branch ruleset without affecting the main rulesets or each other. Branches allow rule isolation, easy review, and merge control through the Branch Review process. Once development is complete, the branch can be merged back into the application, reducing risks of overwriting others’ work. This is best practice in team-based development environments.

Reference:
Pega Community – Branching strategy for team development

C. Create a separate production ruleset for each team :
Production rulesets are intended for business users or delegated rules, not for active development. Using production rulesets for development would be a misuse of the feature and could cause issues in deployment and rule resolution. These rulesets aren’t versioned and may bypass approval processes, making them unsuitable for structured development collaboration. This does not offer rule isolation or version control per team and is not a recommended approach.

Reference:
Pega Academy – Delegating rules using production rulesets

D. Create a new application for each team built on the base application:
This is another viable solution. Each team can be assigned a separate layered application that is built on the base app. This allows teams to have their own rulesets, configurations, and testing environments without impacting others. It's particularly useful when teams work on different features or modules. After development, teams can merge their changes into the base application. This promotes isolation and independent deployment pipelines, making it a safe and scalable approach for large teams.

Reference:
Pega Community – Creating layered applications

Final Answer:
B. Create branches in each team's application
D. Create a new application for each team built on the base application

explanation

A. The PegaRULES database contains rules while PegaDATA contains work instances.
This statement is true and reflects a core architecture design of the Pega Platform. The PegaRULES database (or schema) typically stores rule instances (such as flows, data transforms, UI rules), while the PegaDATA database (or schema) contains work instances, such as cases, assignments, and other runtime data. This data-rule separation is critical for scaling, performance, and logical organization, and it enables easier backup and restore strategies. It is also a best practice to separate rule and data layers.

Reference:
Pega Community – Data storage best practices

B. The Database Table rule allows configuration of a connection to a specific table.
This is true. The Database Table rule in Pega is used to map a class to a physical database table. This configuration allows you to define or override the database table a specific class writes to or reads from. It's especially useful when integrating with external databases or custom schemas. This rule also specifies which database alias to use and can help with partitioning or sharding strategies when managing large volumes of data.

Reference:
Pega Documentation – Class-to-table mapping

C. The History record table contains a record of when each user logged in to the system.
Incorrect. The history tables in Pega (e.g., pc_history_work) are used to store audit trail information related to cases, such as status changes, user actions, and assignments. They do not store user login history. Login events are tracked via log files or security audit mechanisms such as Pega Security Event logs or external monitoring tools (e.g., Splunk). If user login tracking is needed, it must be configured separately.

Reference:
Pega Platform Security Design – Auditing and Logging

D. The report definition rule should only be used against one table for performance reasons.
This is not always true. While joining too many tables in a Report Definition can impact performance, Pega supports joins through class joins and association rules. Report Definitions can access multiple tables when needed, especially for business reporting. What matters is how well the report is optimized (indexes, filters, join strategy), not just the number of tables. So this statement oversimplifies the situation and is not a strict rule or requirement.

Reference:
Pega Community – Report definition performance tips

Final Answer:
A. The PegaRULES database contains rules while PegaDATA contains work instances.
B. The Database Table rule allows configuration of a connection to a specific table.

Explanation:

To allow a Pega mobile app to work offline, you need to ensure that the application can simulate or cache necessary data normally retrieved from external systems. This is essential because when offline, the app cannot make live calls to external data sources (like REST APIs, databases, etc.).

A. Simulate external data sources when the application is offline.
This is the appropriate configuration to support offline capabilities. In Pega, when developing offline mobile apps, you must simulate external data sources so the application can still function without a network connection. This involves creating data transforms or decision rules that mimic expected external data. It ensures that forms, drop-downs, and other fields still populate and function properly during offline use.

Reference:
Pega Docs – Offline mobile apps

B. Source repeating layouts using report definitions.
Using report definitions requires live database access, which is not possible when offline. Therefore, sourcing repeating layouts this way does not support offline mode unless the data is cached or simulated.

C. Configure UI elements to use native controls on mobile devices.
This improves the user experience (UX) but does not address offline access to the application. Native controls affect rendering, not data availability.

D. Source drop-down lists using data pages.
This could work only if the data pages are configured as offline-capable and locally sourced. But if the data page pulls from an external system, it will fail offline. So it's not a reliable standalone solution without additional offline setup (e.g., simulation or caching).

Final Answer:
A. Simulate external data sources when the application is offline

explanation

A. A mashup display starts by calling either a flow or a harness from a Pega application.
Pega Web Mashups are embedded Pega interfaces within an external webpage. The mashup starts by referencing a flow, harness, or assignment, depending on the use case. This is specified in the data-pega-action attribute of the mashup code (pega.web.api), such as: html Copy Edit

explanation

A. Configure the Patient visit case type to allow multiple users.
Allowing multiple users on the parent (Patient Visit) case enables the doctor to access it simultaneously while others (staff) are handling child cases. This is necessary to avoid lock conflicts and support concurrent updates.

B. Configure the Lab analysis and Diagnostic imaging case types to allow other users to open the parent case type.
This setting allows users working on child cases (e.g., lab technicians or radiologists) to access the parent case — making sure the case locking model supports collaboration. This helps maintain data consistency and context when viewing/updating related information in the parent case.

C. Configure the Lab analysis and Diagnostic imaging case types to allow one user.
This restricts child case access to only one user at a time, which does not help collaboration and does not meet the requirement of allowing concurrent parent-child case interaction.

D. Configure the Patient visit case type to allow one user.
Allowing only one user on the parent case would prevent the doctor from updating it while child cases are in progress. This would likely lead to lock conflicts.

Final Answer:
A. Configure the Patient visit case type to allow multiple users.
B. Configure the Lab analysis and Diagnostic imaging case types to allow other users to open the parent case type.

explanation

A. Use an action object configured as a script to perform additional actions on a web mashup gadget.
You can configure Mashup actions (such as button clicks) to trigger JavaScript scripts. These scripts enable the gadget to send or retrieve data dynamically.

B. Use the JavaScript function doAction() to set or read data values through the hosting web page.
pega.web.api.doAction() is part of the Pega Mashup JavaScript API and is used for: Setting values in the case Getting values from fields Submitting the assignment It facilitates two-way data communication.

C. Use an SQL call to exchange data between the mashup and hosting web page.
SQL is strictly for backend database interaction. It cannot be used to transfer data between the browser-hosted mashup and the hosting page.

D. Use a queue processor to pass updated attributes to the gadget on the hosting web page.
Queue processors are for asynchronous background processing inside Pega, not for real-time or front-end communication with mashups.

E. Use the data-pega-event-onpagedata attribute to configure the default value for the gadget.
The data-pega-event-onpagedata attribute allows the hosting web page to send default values to the Pega gadget at load time. It triggers a JavaScript event to share data.

Final Answer:
A. Use an action object configured as a script
B. Use the JavaScript function doAction()
E. Use the data-pega-event-onpagedata attribute