Pega LSA flashcards

32 cards. Read the term and the definition here. The deck at the top of this page is optional.

Rule resolution order

Pega resolves a rule by pattern inheritance, then directed inheritance, then the application's ruleset list, then ruleset version precedence, choosing the highest applicable version before moving to the next class.

Pattern inheritance

Inheritance that follows the class name's dot notation, so a class inherits from its parent class automatically. It is evaluated before directed inheritance during rule resolution.

Directed inheritance

Inheritance declared explicitly through a class's Inherits From setting, pointing to a single parent class that need not match the class name hierarchy. It is evaluated after pattern inheritance.

Circumstancing precedence

A circumstance-qualified rule overrides its base rule regardless of ruleset position. When several circumstances apply, the rule with more matching qualifiers wins over one with fewer.

Built-on application

A reusable parent application whose rules are available to the child application. The child's rules take precedence, and the parent's ruleset stack is resolved separately from the child's.

Data Page scope

Data Pages load in Thread, Requestor, or Node scope. Node scope is shared by all requestors on a node and suits large, stable reference data; Thread scope is per-interaction and least shared.

Case lifecycle stages

A case type defines stages such as Create, Process, and Resolve. Each stage contains a process flow, and alternate stages or optional processes change the available path without altering the class structure.

Enterprise Class Structure

A layered class hierarchy from Organization to Division to Unit to Application to Case Type to Work Class, where rules are inherited downward and placed at the highest class where they are universally valid.

Ruleset version precedence

Among rulesets in the application stack, a higher major.minor version wins over a lower one. Within the same version, the highest patch number is selected.

Guardrail compliance score

A Pega Platform metric that flags design practices such as activities in UI or unnecessary custom code, helping architects assess maintainability and upgrade readiness of an application.

Declarative rule types

Constraints, OnChange, and Calculation rules fire automatically when referenced properties change. They keep logic on properties rather than in flows or activities, reducing procedural code.

Application stack

The ordered set of applications, including built-on applications, whose rules are visible to the current application. The child application's rules override those of its parents.

Class group

A grouping of classes that share rule resolution visibility, often used to organize work classes and data classes so that rules defined in one are available to the group.

Access group and roles

An Access Group binds a requestor to an application, a ruleset list, and roles. Roles grant privileges that control which actions and rules a user may use.

Thread vs requestor scope

Thread-scoped data lives for one interaction and is discarded afterward. Requestor-scoped data persists across interactions for the same user session, so it is more widely shared.

Node scope data

Data loaded once per node and shared by every requestor on that node. It suits large reference or configuration data and requires a reload strategy to manage staleness.

Application Wizard output

The wizard generates the organization, division, and unit structure, the application and built-on application, rulesets, access groups, and the case types selected during setup.

Case Type rule

Defines a case's stages, processes, and work class. It determines the data model through case properties and attached data types, and governs the available lifecycle paths.

Data Type mapping

A Data Type maps a reusable data object to a class through a Data Transform and is exposed via Data Pages. It is distinct from a case type and can be referenced by many cases.

Section rule reuse

Sections are the reusable UI unit; Harness rules compose them into a case layout. Reusing sections across harnesses keeps the interface consistent and reduces duplicate configuration.

Flow Action configuration

Flow Actions define the actions available on a UI and the processing that follows. Configuring actions through Flow Actions avoids hard-coded buttons and keeps behavior driven by the flow.

Smart shape palette

The set of shapes used to build a flow, including assignments, decisions, sub-processes, and utilities. Every path in the flow must reach an end shape.

Sub-process reuse

A sub-process is a flow called from another flow, letting shared logic live in one place. Keeping the main flow thin and moving reusable logic into sub-flows improves maintainability.

Property constraint rule

A constraint enforces a rule on a single property, such as a range or required value. It is declarative and evaluated automatically when the property changes.

Edit Validate rule

A server-side validation rule that runs when a property is submitted. It checks the value and returns an error message when the input fails the validation logic.

OnChange rule

A declarative rule that fires when a referenced property changes, typically to set or recalculate dependent values. It runs automatically without explicit flow logic.

Validate rule

A rule used for cross-property validation, checking relationships among several properties. It should be free of side effects so validation remains predictable and repeatable.

Access Control Policy

A policy that grants or denies access to classes and properties based on conditions, supporting attribute-based access control. It complements roles and privileges in the access group.

Privilege mapping

Privileges are granted through roles in an access group and control specific actions. Mapping roles to privileges keeps authorization explicit and auditable across the application.

Scenario Testing tool

A Pega tool for unit-level case tests that records expected outcomes and reruns them after changes, helping verify case behavior before deployment.

Product rule packaging

A product rule bundles rules for migration between environments. Packaging changes into a product or branch and verifying ruleset versions before promotion supports reliable deployment.

Guardrail report

A report on an application's compliance with Pega design guardrails, highlighting practices that affect maintainability, performance, and upgrade readiness before release.