Study guide

8.2 Role-Based Access Control: Access Roles, ARO & Privileges

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

8.2 Role-Based Access Control: Access Roles, ARO & Privileges

Key Takeaways Explain This Topic AI

Role-Based Access Control (RBAC) in Pega couples reusable Access Roles (Rule-Access-Role-Name) with Access of Role to Object (ARO / Rule-Access-Role-Obj) rules to define class-level permissions on a scale from 0 to 5.

ARO rules govern CRUD actions (Create, Read, Update, Delete) as well as Open Cases, View History, and Execute Reports, with support for conditional evaluation via When rules.

Privileges (Rule-Access-Privilege-Name) provide atomic, granular authorization tokens applied to sensitive Flow Actions, Processes, Stages, or Activities, granted conditionally or unconditionally via the ARO Privileges tab.

When an operator belongs to an Access Group with multiple Access Roles, Pega resolves permissions using the 'highest permission wins' principle (most permissive access across all roles).

If a specific class lacks an explicit ARO rule, the Pega security engine traverses pattern and directed inheritance until a matching ARO rule is resolved or access is denied at @baseclass.

Last updated: September 2026

8.2 Role-Based Access Control: Access Roles, ARO & Privileges

In Pega Platform, Role-Based Access Control (RBAC) is the foundational security model governing what actions a user can perform on specific classes and rule types. While an Access Group connects an operator to an application and portal, RBAC determines whether that user can open a case, modify properties, delete records, run reports, or execute sensitive transactional stages.

Understanding the mechanics of Access Roles ( Rule-Access-Role-Name ), Access of Role to Object (ARO) rules ( Rule-Access-Role-Obj ), and granular Privileges ( Rule-Access-Privilege-Name ), along with Pega's multi-role resolution algorithm, is a heavily tested topic on the Certified Pega System Architect exam.

1. Role-Based Access Control (RBAC) Architecture

Pega's RBAC framework enforces the security principle of least privilege , ensuring users possess only the permissions required to fulfill their business responsibilities. The architecture is structured around three foundational rule types: +-------------------------------------------------------------------------+

  • | PEGA RBAC CORE ENTITIES |
  • +-------------------------------------------------------------------------+
  • | [1] ACCESS ROLE NAME (Rule-Access-Role-Name) |
  • | Reusable security persona label (e.g., LoanApp:Underwriter) |
  • | |
  • | [2] ACCESS OF ROLE TO OBJECT (ARO) (Rule-Access-Role-Obj) |
  • | Security matrix mapping an Access Role to a specific Class |
  • | Defines CRUD permissions (0-5) and conditional When rules |
  • | |
  • | [3] PRIVILEGE (Rule-Access-Privilege-Name) |
  • | Atomic security token granting right to execute a discrete action |
  • | Checked on Flow Actions, Stages, Activities, and Flows |
  • +-------------------------------------------------------------------------+
  • The RBAC Authorization Chain

An Operator logs in and is initialized with an active Access Group .

The Access Group contains an array of Access Roles .

For each Access Role, the system evaluates matching Access of Role to Object (ARO) rules for the target case or data class.

The ARO defines class-level operation permissions (0 to 5) and grants specific Privileges .

When a user attempts to execute a case action or open a screen, Pega verifies that the user's role hierarchy grants the necessary ARO level and required Privileges.

2. Access Roles ( Rule-Access-Role-Name )

An Access Role is a named authorization persona that defines a specific job function or security classification within an application.

Characteristics and Naming Conventions

An Access Role name rule ( Rule-Access-Role-Name ) contains no logic or settings of its own; it serves as a reusable identifier or grouping key.

Pega best practice dictates naming roles using the pattern ApplicationName:RoleName :

LoanApp:User : Standard case workers who create and process general cases.

LoanApp:Underwriter : Subject matter experts who evaluate risk and approve terms.

LoanApp:Manager : Supervisors with reporting, transfer, and reassignment authority.

LoanApp:Administrator : IT administrators with system configuration rights.

PegaRULES:SysAdm4 : The out-of-the-box system administrator role granting full platform development and administrative access.

An Access Group can reference multiple Access Roles simultaneously. For example, a senior supervisor might be assigned both LoanApp:Underwriter and LoanApp:Manager within their LoanApp:Supervisors Access Group.

3. Access of Role to Object (ARO / Rule-Access-Role-Obj )

The Access of Role to Object (ARO) rule is the heart of Pega RBAC. An ARO links an Access Role to a specific Class ( Applies-To ) and explicitly defines what operations users holding that role may perform on instances of that class.

The Permission Operations

Each ARO configuration matrix specifies permissions for seven standard operations:

Operation Description Runtime System Impact

Open Cases / Instances ( pyReadInstance ) Permission to view and open an existing case or data record in memory. Controls whether a case can be loaded into the clipboard ( pyWorkPage ).

Modify Cases / Instances ( pyWriteInstance ) Permission to update, edit fields, and save changes to a case or data record. Controls whether Obj-Save or case update commits succeed.

Delete Cases / Instances ( pyDeleteInstance ) Permission to permanently purge or delete a case or data instance from storage. Controls Obj-Delete execution and case deletion menu actions.

Open Rules ( pyReadRule ) Permission to view rule definitions residing in the class. Relevant when authoring or inspecting rules in Dev Studio.

Modify Rules ( pyWriteRule ) Permission to create, check out, and save rules in the class. Restricts rule authoring to developers and system architects.

Delete Rules ( pyDeleteRule ) Permission to delete or withdraw rules in the class. Reserved for development leads and administrators.

Execute Reports ( pyExecuteReport ) Permission to run Report Definitions querying instances of this class. Controls reporting execution and dashboard chart loading.

The 0 to 5 Permission Scale

Permissions for each operation are defined using an integer scale from 0 to 5 :

0 (No Access) : Explicitly denies the operation. Users with this role cannot perform the action.

1 to 4 (Conditional / Tiered) : Used in specialized legacy designs or combined with custom security thresholds.

5 (Full Access) : Unconditionally authorizes the operation.

Dynamic Access with When Rules

Rather than entering a static integer between 0 and 5, architects can enter the name of a When rule ( Rule-Obj-When ) into any operation field:

If the When rule evaluates to true at runtime, Pega treats the permission level as 5 (granted).

If the When rule evaluates to false , Pega treats the permission level as 0 (denied).

Common Real-World Example : Setting the Modify Cases permission on UPlus-Loans-Work-Mortgage to a When rule named IsCaseModifiable : IsCaseModifiable When Condition:

.pyStatusWork != "Resolved-Completed" AND .pyStatusWork != "Resolved-Rejected"

This ensures underwriters can modify cases while they are actively progressing, but prevents any edits once a case reaches a resolved status.

4. Privileges ( Rule-Access-Privilege-Name )

While ARO CRUD settings control broad class-level capabilities, enterprise workflows require fine-grained authorization over specific transactional actions. This is accomplished using Privileges ( Rule-Access-Privilege-Name ).

A Privilege is an atomic, discrete security token that authorizes an operator to execute a specific sensitive action. ARO (Privileges Tab) FLOW ACTION (Security Tab)

  • ┌─────────────────────────────┐ ┌─────────────────────────────┐
  • │ Role: LoanApp:Underwriter │ │ Flow Action: OverrideRate │
  • │ Class: UPlus-Loans-Work- │ │ Required Privileges: │
  • │ Grants: CanOverrideRate │ ─────> │ - CanOverrideRate │
  • │ (Unconditional or When rule)│ │ (Action blocked if missing) │
  • └─────────────────────────────┘ └─────────────────────────────┘
  • Where Privileges Are Enforced

Architects attach required privileges to sensitive platform components:

Flow Actions ( Rule-Obj-FlowAction ) : Configured on the Action tab under Security . If a user does not possess the specified privilege, the flow action will not appear in the UI actions dropdown, and the engine rejects any attempt to submit it.

Case Stages ( Rule-Obj-CaseType ) : Restricts entry or execution of specific stages (e.g., an Executive Settlement stage) to users holding a designated privilege.

Activities ( Rule-Obj-Activity ) : Configured on the Security tab under Privileges . If an activity is invoked without the caller holding the privilege, the engine halts execution with a security violation.

Flows and Sub-processes : Restricts manual flow launching to authorized personas.

Granting Privileges via the ARO Rule

Privileges are granted within the Privileges tab of the ARO rule form:

The architect adds the privilege name (e.g., CanOverrideCreditLimit or ReopenResolvedCase ).

The grant can be unconditional (level 5) or governed by a When rule (e.g., grant CanOverrideCreditLimit only When .ApplicantCreditScore > 750 ).

5. Security Resolution Algorithm & Multi-Role Inheritance

Enterprise operators frequently hold multiple Access Roles within their Access Group. Furthermore, classes inherit rules through Pattern and Directed inheritance. How does Pega determine whether an action is permitted?

A. The Multi-Role Union Rule: "Highest Permission Wins"

When an operator's Access Group references multiple Access Roles, Pega evaluates all ARO rules applicable to that class across all assigned roles and applies the most permissive result : Effective Permission = max ⁡ ( Role 1 , Role 2 , … , Role n ) \text{Effective Permission} = \max(\text{Role}_1, \text{Role}_2, \dots, \text{Role}_n) Effective Permission = max ( Role 1 ​ , Role 2 ​ , … , Role n ​ )

If Role_A grants Write permission 0 and Role_B grants Write permission 5 , the operator receives 5 (Allowed) .

Critical Architectural Principle : In Pega RBAC, there is no "veto" or explicit deny role that overrides an allowed role. The highest integer wins.

If multiple roles specify When rules, Pega evaluates them with logical OR : if any When condition evaluates to true , access is granted.

B. Class Inheritance Resolution for ARO Rules

If no explicit ARO rule exists for the specific case class, the Pega security engine traverses the class hierarchy using Pattern Inheritance and Directed Inheritance :

Pega searches for an ARO rule defined directly on the target class (e.g., UPlus-Loans-Work-Mortgage ).

If not found, the engine follows Pattern inheritance to search parent classes (e.g., UPlus-Loans-Work- , then UPlus-Loans- , then UPlus- ).

If still not found, the engine evaluates Directed inheritance parents (e.g., Work-Cover- , Work- , and finally @baseclass ).

First Match Stops the Search : The engine uses the first matching ARO rule encountered along the inheritance path for that role. It does not merge ARO settings across different levels of the class inheritance chain for the same role.

If @baseclass is reached without finding an ARO rule for that role, the operation is denied (0) by default.

6. Security Anti-Patterns & CSA Exam Traps

Security Anti-Pattern Operational Vulnerability Recommended Architecture

Assigning PegaRULES:SysAdm4 to business users Grants unfettered access to Dev Studio, system tables, and rule modification in production. Create dedicated business roles (e.g., App:Supervisor ) with restricted AROs and User Portals.

Relying solely on UI hiding instead of Privileges Hiding a button via UI visible-when conditions does not secure the server. A malicious client can still post the flow action via HTTP. Always secure the underlying Flow Action with a Privilege . UI visibility should reflect, not replace, server-side security.

Assuming 0 overrides 5 in multi-role Access Groups Developers mistakenly believe adding a "read-only" role will restrict an operator who already has an administrative role. Remember: Highest permission wins . To restrict access, the high-privilege role must be removed from the Access Group.

Defining redundant ARO rules on every child class Massively inflates rule maintenance and causes synchronization errors when security policies update. Define baseline ARO rules at the work pool or framework level ( Work- or App-Work- ) and specialize only where needed.

Loading diagram... Pega RBAC Security Authorization Hierarchy & Resolution