Pega LSA study plan

Map the Pega architecture stack end to end: explain how the web tier, application server, database, and background processing nodes interact, and where each runs in a typical deployment

Diagram a multi-node deployment (load balancer, web tier, app nodes, search node, background processing) and annotate the traffic flow and failure points

Distinguish application, ruleset, and ruleset stack layering, and articulate how rule resolution order is determined by class inheritance plus ruleset ranking

Write out the difference between situational layer-cake inheritance and direct inheritance, with one concrete design scenario for each

Explain node classification and node types, and justify which node types are required for background processing, search indexing, and real-time processing

Describe the role of the database schema, rule schema versus data schema separation, and how schema changes are promoted between environments

Compare the available high-availability and scalability strategies and state the trade-offs of each for session affinity, caching, and background processing

Identify the security architecture layers: authentication, authorization, attribute-based access control, and data privacy, and where each is enforced

Trace the guardrail and performance-related design constraints and explain how they influence architecture decisions rather than just build-time warnings

Describe the deployment pipeline from development through staging to production, including ruleset versioning, product packaging, and schema migration ordering

Explain how the Pega platform handles caching at the rules level, the data level, and the static content level, and when each cache must be invalidated

Analyze integration architecture options (service, connector, queue-based, and batch) and select the appropriate pattern for a given latency and volume profile

Consolidate architecture knowledge by answering timed practice questions across all domain 1 subareas and recording accuracy per subarea

Set up a clean personal development environment with a working application server, database, and search configuration sufficient to build and test application artifacts

Create a case type hierarchy and data model for a realistic business scenario, including class structure, data types, and inheritance decisions

Document the design decisions from the case type exercise with justification tied to architecture principles

Build a complete case lifecycle with stages, processes, and alternate paths, including at least one optional process and one conditional transition

Implement declarative processing (expressions, constraints, calculations, and on-change handling) instead of procedural logic where declarative rules are appropriate

Configure data pages and data transforms to source and persist data, and explain the caching scope choice for each data page

Implement routing and assignment logic including skills-based routing and service-level agreements with escalation

Build integrations using a REST connector and expose a REST service, including error handling, mapping, and simulation for testing

Implement security controls in the application: access roles, attribute-based access conditions, and data masking for sensitive properties

Design and build a report definition and a landing page that surface case data with appropriate filtering and access control

Add background processing such as a job scheduler or queue processor and verify it behaves correctly under failure and retry

Refactor the built application to remove duplication by consolidating rules into reusable patterns and appropriate inheritance layers

Run the guardrail compliance check and resolve or justify every warning and severely flagged item

Implement situational layer-cake behavior for at least one rule type and verify rule resolution at runtime

Perform a performance pass on the application: review data page scoping, avoid unnecessary rule resolution churn, and validate list filtering at the source

Complete a full timed mock exam covering both domains and review every incorrect answer to root cause, not just the correct option

Re-derive the architecture decisions in the week 2 record from memory and correct any gaps

Rebuild one core application feature from scratch without reference to the original, to confirm hands-on fluency

Produce a personal weak-area list with a concrete remediation action for each item