Pega Platform Fundamentals Quiz

In PRPC, work object IDs are generated using auto-numbering rules. The standard pattern uses 'GenerateID' suffix with appropriate prefix. Option B shows the correct pattern, though there may be formatting issues in the display. Options A, C, D don't follow the standard PRPC work object ID naming conventions.

In the PRPC Work Object Model, the hierarchy is: Folder (top level) contains Cover pages, which in turn contain Basic pages. Folder → Cover → Basic is the correct containment structure. This organizes work from general (Folder) to specific (Basic pages).

For a rule set 'XXX' with 5 versions, Rule-RuleSet-Name (the class) has 1 instance (representing the rule set itself), while Rule-RuleSet-Version has 5 instances (one for each version: XXX-01, XXX-02, XXX-03, XXX-04, XXX-05). This is a fundamental PRPC rule versioning concept.

All three formats shown are valid work object IDs in PRPC: W-1234-S (standard work ID), W-1234 (simplified format), and Pega-1234-Work (Pega platform format). Work object IDs can follow different patterns depending on configuration and class structure.

All the listed options (Connector, Notify, Router, Trigger, Assembler) are valid activity types in Pega. Since the question asks which is 'not a type of Activity' and all listed options are valid, 'None of the Above' (option F) is logically correct - there is no invalid option among A-E.

In Pega, a connector that originates from an Assignment shape is specifically called a 'Flow Action'. Flow actions define the user interaction and processing that occurs when an assignment is completed. Local actions are different - they are additional actions available while on an assignment. Branches are decision points in flows, not connectors from assignments.

In Pega, work classes within a class group typically map to the class group table, which defaults to pc_work. However, unless explicitly mapped otherwise, standard behavior for concrete classes not designated as part of a work pool is to fall back to the default pr4_base table.

SmartBuild in Pega follows a logical sequence: first establish the Class Structure (data model foundation), then define Properties (attributes), then create the User Interface (forms/screens), and finally implement Activities (business logic and processing). This sequence ensures data structure exists before UI is built, and UI exists before process flows are defined.

The question lists several connector types but has issues. Standard Pega connectors in flows include: FlowAction (to assignments), Always (unconditional), When/Else (conditional branching), and various other types. However, the list includes 'LocalAction' and 'Action' which are not standard flow connector types in traditional Pega flows. The question phrasing is confusing.

In Pega's access control hierarchy: Applications reference Access Groups (which define permissions and roles), and Access Groups reference Operator IDs (users). The structure is: Application -> Access Group -> Operator ID. Each level is referenced by the level above it, creating a chain of authorization.

A 'Transition' in a Pega activity is a true/false condition that is evaluated before each step executes. If the transition evaluates to true, the activity continues to the next numbered step. If false, the activity skips subsequent steps and exits. This provides conditional flow control within activities.

Pega's implementation methodology (Direct Capture of Objectives, SmartBuild, etc.) is based on the Rational Unified Process (RUP). RUP provides the iterative, use-case-driven framework that Pega adapts for its low-code platform. This influences how projects are structured with phases, iterations, and deliverables.

Rules Inspector in Pega shows various rule types and their dependencies. Field Value rules, Declarative rules, Property rules, and Styles can all appear in Rules Inspector depending on context. Since all these types are found in Rules Inspector, 'None of the Above' (option E) is correct - there is no type listed that is NOT found.

When a work object is first created in Pega, its initial status is 'new'. This is the starting status before any processing or assignment occurs. The work object then progresses through statuses like 'open', 'resolved', 'pending', etc. based on the business process and SLA rules defined.

In Ab Initio, declare pages can be of both thread and node types. This flexibility allows declare pages to be used in different parallel processing contexts - thread-level for shared memory operations and node-level for distributed processing across partitions.

The Top-Down Approach in Pega involves defining properties and rules at higher levels in the class hierarchy (like base classes), which are then inherited by all derived leaf classes. This promotes reuse and consistency across the application. Cross-Class Approach is not a standard Pega term, while Streamlined Process and Application Accelerator refer to different concepts in the Pega platform.

In Pega class hierarchy creation, you establish the base class first, then build the work class hierarchy before data classes. Work classes (IV-VIII) are created before data classes (II-III) because work objects typically reference data classes. Within work classes, you create from general (PegaRP-Work) to specific (Work-Object, then specialized types like Work-Object-Admin and Work-Project-Inquiry).

In Pega, Product rules are specifically designed to package and migrate both rules and data instances between environments. System rules handle platform-level configurations, not migration. The Product rule acts as a container that bundles related rules and data for deployment.