Study guide
4.1 Data Objects, Property Modes & Page Types
Pegasystems Certified Pega System Architect CSA
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Exam Overview & Architecture Foundations
1.1 Certified Pega System Architect Exam Format, Blueprint & Strategy 1.2 Pega Architecture & Enterprise Class Structure (ECS) 1.3 Studio Environments: App Studio, Dev Studio, Admin Studio & Prediction Studio
2 Chapter 2: Case Lifecycle Design & Core Workflows
2.1 Case Types, Stages, Processes, and Steps 2.2 Routing Strategies: Worklists, Work Queues, and Teams 2.3 Service Level Agreements (SLAs) & Urgency Calculations
3 Chapter 3: Advanced Case Management Patterns
3.1 Multi-Step Processes, Parallel Processing & Sub-processes 3.2 Child Cases, Data Propagation & Wait Steps 3.3 Optional Actions, Approvals & Case Resolution 3.4 Duplicate Case Detection, Automation Shapes & Automated Correspondence
4 Chapter 4: Data Modeling & Data Page Architecture
4.1 Data Objects, Property Modes & Page Types 4.2 Data Pages: Scope, Types & Refresh Policies 4.3 Data Transforms & Object Mapping
5 Chapter 5: Business Logic, Calculations & Decisioning
5.1 Declare Expressions & Declarative Network Chaining 5.2 Decision Tables & Decision Trees 5.3 Integration Connectors, Systems of Record & Error Handling
6 Chapter 6: User Interface & User Experience Design
6.1 Traditional UI vs Constellation Architecture 6.2 Views, Dynamic Layouts, Design Templates & Action Sets 6.3 Form Validation, Edit Validate & WCAG Accessibility 6.4 Form Views: Default vs Hierarchical Forms, Field Groups & Primary Fields
7 Chapter 7: Rule Architecture & Rule Resolution
7.1 Rulesets, Versioning & Ruleset Stack Hierarchy 7.2 The Rule Resolution Algorithm 7.3 Circumstancing & Rule Specialization
8 Chapter 8: Security & Access Control
8.1 Authentication, Operator Records & Access Groups 8.2 Role-Based Access Control: Access Roles, ARO & Privileges 8.3 Attribute-Based Access Control (ABAC), Encryption & Audit Trails 8.4 The Security Checklist & Secure Deployment
9 Chapter 9: DevOps, Testing & Application Quality
9.1 Guardrail Compliance, Best Practices & Performance Profiling 9.2 Automated Testing: Pega Unit Test Cases & Scenario Testing 9.3 Packaging, Branching & Deployment Manager CI/CD
10 Chapter 10: Reporting & Operational Analytics
10.1 Report Definitions: Querying, Columns, Summaries & Joins 10.2 Filtering, Parameters & Column Exposure Optimization 10.3 Insights, Visual Dashboards & Business Metrics
11 Chapter 11: Mobility, Digital Channels & Portals
11.1 Mobile Channel Configuration & Offline Processing 11.2 Web Mashup, Digital Channels & Constellation Embed 11.3 Channels, Personas, Portals & Landing Pages
12 Chapter 12: Center-out Architecture, Enterprise Reuse & Agile Delivery
12.1 Center-out Business Architecture & the Case for Pega 12.2 The Situational Layer Cake, Modules & Enterprise Reuse 12.3 Agile Workbench, Workspaces, Branches, Delivery Roles & the Estimator
13 Chapter 13: Pega GenAI for System Architects
13.1 Pega Blueprint: Creating, Importing & Modifying an Application Design 13.2 Pega GenAI Autopilot & Pega GenAI Coach 13.3 Pega GenAI Connect Rules, Knowledge Buddy, Agents & Tool Rules
4.1 Data Objects, Property Modes & Page Types
Key Takeaways Explain This Topic AI
In Pega, Data Types (Data Objects) represent reusable business entities inheriting from Data-, keeping domain information cleanly decoupled from case processing classes inheriting from Work-.
Property modes are divided into Value Modes (storing scalar values without child attributes) and Page Modes (storing instances of Pega classes with structured child properties).
Value Lists and Page Lists represent ordered collections indexed by positive integers (1..N), whereas Value Groups and Page Groups represent unordered associative collections keyed by string subscripts.
Scalar properties are defined with technical types such as Text, Identifier, Integer, Decimal, Date, TimeOfDay, DateTime, and TrueFalse to enforce formatting and validation constraints.
System of Record (SOR) stores master authoritative data, System of Reference provides on-demand cached views without persisting redundant copies on the case, and Temporary data objects support ephemeral calculations.
Last updated: September 2026
4.1 Data Objects, Property Modes & Page Types
CSA Exam Focus: Understanding the Pega data model is critical for designing scalable, maintainable enterprise applications. Certified Pega System Architects must understand how business data is structured across the class hierarchy, how Value Modes differ from Page Modes, when to use ordered lists versus associative groups, how scalar property types enforce validation, and how to apply System of Record (SOR) versus System of Reference architectural patterns.
Pega Data Architecture: Work Classes vs. Data Classes
Pega applications enforce a strict separation of concerns between business transaction processing and the domain data entities that support those transactions. This separation is architected through the class hierarchy:
Work Classes ( Work- )
Case types inherit from Work- (or Work-Cover- ). Work classes represent dynamic business processes that move through stages, processes, and steps toward a business resolution. Properties defined directly on a work class (such as .pyStatusWork , .pxUrgencyWork , or .LoanAmount ) track the state, progress, and transaction-specific attributes of a single case instance.
Data Classes ( Data- )
Data types—referred to as Data Objects in App Studio—inherit from Data- . Data classes represent reusable business entities that exist independently of any specific case lifecycle. Examples include MyOrg-Data-Customer , MyOrg-Data-Address , MyOrg-Data-Account , and MyOrg-Data-Vehicle . Data classes encapsulate the fields, validation rules, and integration data pages required to model and interact with enterprise entities. Cases reference instances of these data classes rather than redefining individual customer or account fields inside the case type.
App Studio Fields vs. Dev Studio Properties
When a citizen developer or business architect defines a "Field" in App Studio (for example, adding a customer email field to a view), Pega automatically creates an underlying Property rule ( Rule-Obj-Property ) in Dev Studio. System architects working in Dev Studio configure advanced property settings, including property modes, data access rules, UI formatting qualifiers, and table validations.
Property Modes: Value Modes vs. Page Modes
Every property in Pega has a Property Mode that determines whether it holds raw scalar data or structured class instances, and whether it stores a single item or a collection of items.
Pega categorizes property modes into two primary families:
Value Modes : Store scalar, un-typed or primitive data values directly. Value mode properties do not have child properties or inner attributes.
Page Modes : Store complex Pega class instances (pages). A page mode property points to a defined class and contains child properties, embedded pages, or lists of pages. +---------------------------------+
- | Pega Property Modes |
- +----------------+----------------+
- |
- +-----------------------------+-----------------------------+
- | |
- v v
- [Value Modes] [Page Modes]
- (Stores scalar/primitive values) (Stores class instances / pages)
- Single Value: .PostalCode = "02142" - Page: .Customer.Name = "Acme"
- Value List: .PhoneNumbers(1) = "555-0199" - Page List: .LineItems(1).SKU = "A12"
- Value Group: .PhoneNumbers("Home") = "555-0199" - Page Group: .Addresses("Bill").City = "BOS"
- Deep Dive: Value Modes
Value modes store raw data values without an associated class structure:
1. Single Value
Holds a single scalar value. This is the most common property mode for simple case and data attributes.
- Syntax : .CustomerName , .TaxRate , .IsActive
- Examples : .CustomerName = "Jane Doe" , .TaxRate = 0.0625 , .IsActive = true
- 2. Value List
An ordered collection of scalar values indexed by positive integers starting at 1 (1-based indexing: 1, 2, 3, ... N ).
Subscript Type : Integer index ( 1..N ).
Ordering : Strictly ordered. Elements maintain their sequential insertion position.
Common Use Cases : Chronological search history, ordered priority codes, tags, or simple lists where position matters but child attributes are not required.
- Syntax : .SearchKeywords(1) = "Mortgage" , .SearchKeywords(2) = "Refinance"
- 3. Value Group
An unordered associative array (key-value dictionary) of scalar values keyed by arbitrary text strings (subscripts).
Subscript Type : String / Text subscript (enclosed in double quotes).
Ordering : Unordered. Elements are retrieved by their descriptive key name rather than a numerical position.
Common Use Cases : Categorized contact numbers, localized phone labels, or environment configuration parameters.
Syntax : .PhoneNumbers("Home") = "555-0100" , .PhoneNumbers("Mobile") = "555-0199" , .PhoneNumbers("Work") = "555-0144"
Deep Dive: Page Modes
Page modes represent structured instances of Pega classes. Every page mode property must explicitly define its Page Class (e.g., MyOrg-Data-Address ):
1. Page (Single Page)
A single instance of a specified class. It encapsulates a structured entity containing its own set of child properties.
Structure : A standalone embedded clipboard page.
Common Use Cases : Representing a primary customer record, billing address, policy summary, or credit score report on a case.
- Syntax : .Customer.FirstName = "Robert" , .BillingAddress.PostalCode = "10001"
- 2. Page List
An ordered collection of class instances (pages) indexed by positive integers ( 1..N ).
Subscript Type : Integer index ( 1..N ).
Ordering : Strictly ordered. Supports sorting, appending, inserting at index, and iterating sequentially.
Common Use Cases : The most widely utilized aggregate property mode in Pega. Used for repeating business records such as purchase order line items, insurance claim injury lists, bank account transaction histories, and loan co-borrower records.
- Syntax : .LineItems(1).SKU = "PROD-100" , .LineItems(1).Quantity = 2 , .LineItems(2).SKU = "PROD-205"
- 3. Page Group
An unordered associative array (collection) of class instances (pages) keyed by arbitrary text subscripts.
Subscript Type : String / Text subscript (enclosed in double quotes).
Ordering : Unordered. Elements are addressed directly by their meaningful business key.
Common Use Cases : Multi-address structures keyed by address purpose ("Billing", "Shipping", "Corporate"), vehicle records keyed by Vehicle Identification Number (VIN), or insurance coverage endorsements keyed by endorsement type ("Collision", "Comprehensive", "Liability").
Syntax : .Addresses("Billing").City = "Boston" , .Addresses("Shipping").City = "Cambridge" , .Coverages("Collision").DeductibleAmount = 500
Technical Property Types (Scalar Types)
For properties configured in Single Value, Value List, or Value Group modes, Pega requires selecting a technical Property Type . This type governs how the platform formats, parses, and validates the data in memory and during database persistence:
- Technical Type Internal Storage Format Description & Constraints Sample Valid Value
- Text java.lang.String Unrestricted alphanumeric characters, punctuation, and spaces. "Suite 400, North Tower"
Identifier java.lang.String Alphanumeric characters without whitespace or special symbols (except underscore/hyphen). Ideal for keys, codes, and IDs. "CUST_99401"
Integer java.lang.Integer Whole signed numbers (-2,147,483,648 to 2,147,483,647). No decimals. 42
Decimal java.math.BigDecimal High-precision floating point numbers. Essential for currency, exchange rates, and financial interest rates. 1250.75
Date YYYYMMDD (String) Calendar date without time components. Stored internally as an 8-character string. "20260921"
TimeOfDay HHMMSS (String) Time of day without calendar date or time zone offset. Stored as a 6-character string. "143000"
DateTime YYYYMMDDTHHMMSS.mmm GMT Coordinated Universal Time (UTC/GMT) timestamp with millisecond precision. Localized automatically by UI controls. "20260921T173000.000 GMT"
TrueFalse java.lang.Boolean Binary boolean value. Stored internally as lowercase strings "true" or "false" . true
Systems of Record: SOR vs. Reference vs. Temporary Data
Architecting enterprise Pega applications requires deciding where data lives, how long it persists, and which system owns the single source of truth.
1. System of Record (SOR)
The System of Record is the authoritative master database, ERP, or CRM system that creates, owns, and permanently persists enterprise entities. Examples include SAP for inventory, Salesforce for sales leads, and core banking mainframes (e.g., FIS, Fiserv) for deposit accounts.
In some applications, Pega itself acts as the System of Record for case data (stored in pc_work tables) and internal data types (stored in dedicated pr_ relational tables).
When external systems own the data, Pega must coordinate updates using integration connectors or Savable Data Pages to synchronize changes back to the SOR.
2. System of Reference
Under the System of Reference pattern, Pega does not persist a duplicate copy of the master data within the case work table ( pc_work ). Instead, Pega queries the authoritative SOR on demand using Data Pages whenever the case needs to display or evaluate the information.
Operational Advantage : Eliminates data duplication, eliminates stale data risks, and maintains compliance with strict data privacy laws (such as GDPR or CCPA) because customer personally identifiable information (PII) is not serialized into the case BLOB.
Case Integration : Cases store only the foreign key (e.g., .CustomerID = "C-501" ). When a view needs to display the customer's name and credit tier, it references D_Customer[CustomerID: .CustomerID].CustomerName . The data is retrieved on the fly and discarded when the user session or interaction concludes.
3. Temporary Data Objects
Temporary data objects are ephemeral clipboard pages created in memory to facilitate in-flight calculations, user selections, or transient validations. They are never persisted to any database table.
Examples : A shopping cart checkout tax estimation page, a pre-qualification loan simulator results page, or a dynamic address verification lookup page.
Once the case advances past the calculation or review step, the temporary page is removed from the clipboard using a Data Transform Remove action to keep memory footprints low.
Property Mode Reference Table & Syntax Guide
The following reference matrix outlines the syntax, subscript mechanisms, and architectural applications for each property mode:
- Property Mode Category Subscript / Index Type Memory Structure Syntax Example
- Single Value Value Mode None (Direct scalar) Scalar variable .CustomerName = "Jane Doe"
- Value List Value Mode Integer ( 1..N ) Ordered array of scalars .PhoneNumbers(1) = "555-0100"
Value Group Value Mode String ( "Key" ) Unordered associative map of scalars .PhoneNumbers("Mobile") = "555-0199"
- Page Page Mode None (Direct page) Standalone class instance .Customer.Addresses(1).City = "Boston"
- Page List Page Mode Integer ( 1..N ) Ordered array of class instances .LineItems(1).Quantity = 5
Page Group Page Mode String ( "Key" ) Unordered associative map of class instances .LineItems("SKU100").Quantity = 5