Pega CPSSA study plan

Diagram the full case life cycle (stages, processes, steps, alternate paths) for a three-stage approval workflow before building anything

Configure a case type with at least two stages and one optional process, then verify stage transitions with the case-wide status values

Build a data type and populate it from a simulated REST integration using a data page with the appropriate scope and refresh strategy

Explain in writing when to use a case-level data page versus a node-level data page and identify the reload behavior of each

Configure declarative processing (expressions, on-change, and data transforms) to calculate and persist derived case values

Design a data model with embedded versus referenced data pages and justify each choice against reuse and performance

Implement a cascading approval routing pattern using a decision table and a router assignment, then test all branches

Trace a failed data page load and document the root cause and fix

Model the case data against a normalized schema and document each property's type, scope, and exposure level

Build a multi-step form flow with validation on at least three fields and a conditional visibility rule

Configure a section with a repeating layout bound to a page list and verify add/remove row behavior

Apply a field-level validation rule that fires on submit and confirm the error message renders at the field

Design and build a responsive harness so the same section renders correctly at desktop and mobile breakpoints

Configure role-based access on a case type by defining access roles and mapping them to concrete operators

Restrict a sensitive property so it is hidden from one role and read-only for another, then verify with two test operators

Document the difference between access-of-role and attribute-based access control conditions with one worked example each

Configure an authentication service and an access group with the correct application and portal alignment

Implement a service-level integration with an authentication profile and test it against a mock endpoint

Audit the application's security settings (password policy, session timeout, locking) and record each default and its risk

Explain how a case type's routing interacts with an operator's access group to determine who can perform an assignment

Design and implement a data page that pulls from an external system with error handling and a fallback source

Configure a data transform to map external response data into the case data model and handle missing fields

Apply encryption or masking to a sensitive property and verify it is unreadable in the UI for an unauthorized role

Write a data governance note covering retention, exposure, and who may read each sensitive property

Build a complete end-to-end case type that spans all four domains: staged process, integrated data, responsive UI, and role-restricted actions

Configure a UI action set so each role sees only the buttons relevant to its permitted transitions

Automate one manual step with a service level and verify escalation behavior when the goal is missed

Run a full case to resolution as two different operators and log every deviation from the intended design

Fix every defect logged in week 7 and retest the affected paths

Re-derive the weakest two domains from a timed practice set and rewrite the notes for each

Summarize each of the four domains on a single page of decision rules a candidate can recall under time pressure

Walk through the end-to-end application aloud, explaining each design choice and its trade-off in under ten minutes