Inheritance is one of the most important concepts in Pega application architecture.
For a beginner, inheritance may sound simple:
But in a Senior Pega Architect interview, that answer is not enough.
The interviewer may continue with:
- How exactly does Pega search for the rule?
- What is Pattern Inheritance?
- What is Directed Inheritance?
- How do they work together?
- What is
@baseclass? - How is inheritance different from the Ruleset stack?
- How does the Application Built-On hierarchy affect rule availability?
- Why is Pega using a particular version of a rule?
- What happens when a rule exists in both the child and parent class?
- What happens when Availability is Blocked or Withdrawn?
- What happens when a Privilege is missing?
- How do you troubleshoot an unexpected rule?
This article answers all of these questions using a fictional banking platform called Nexus and a fictional bank called Alpha Bank.
Inheritance answers "Where can this rule be reused?"
Rule resolution answers "Which rule instance should actually execute?"
Alpha Bank's Inheritance Architecture
Assume Alpha Bank has a Pega banking application called Nexus.
We have multiple Case Types:
- CustomerOnboarding
- LoanApplication
- AccountOpening
- CardApplication
- DisputeManagement
A simplified class architecture could look like this:
The common banking rules can live in Alpha-Banking-Work, while rules specific to a particular Case Type can live in the child class.
This allows us to define common behavior once and reuse it.
1. Explain Alpha Bank's inheritance architecture.
Interview Answer
At Alpha Bank, I would design the class hierarchy so that common banking behavior is placed at the highest appropriate reusable class and specialized behavior is placed in more specific child classes.
For example:
Alpha-Banking-Work
|
+-- CustomerOnboarding
|
+-- LoanApplication
|
+-- AccountOpening
|
+-- CardApplication
If a rule is common to all banking Cases, I place it at Alpha-Banking-Work.
If a rule applies only to Loan Applications, I place it at Alpha-Banking-Work-LoanApplication.
Pega's current inheritance guidance recommends determining rule reusability before deciding where the rule belongs in the class and Ruleset hierarchy.
Example
Suppose every banking Case must validate the customer's relationship status.
Instead of creating the same validation in:
- CustomerOnboarding
- LoanApplication
- AccountOpening
- CardApplication
I can create the reusable rule at:
Alpha-Banking-Work
All child Case Types can then inherit it.
2. What is inheritance in Pega?
Interview Answer
Inheritance allows a Pega class to reuse rules defined in another class instead of duplicating those rules.
Pega provides two primary inheritance mechanisms:
- Pattern Inheritance
- Directed Inheritance
Pega Academy describes inheritance as a mechanism for reusing rules across Cases and applications, reducing development and testing effort.
3. What is Pattern Inheritance?
Interview Answer
Pattern Inheritance is automatic inheritance based on the structure of the class name.
Pega identifies parent classes by the class-name pattern.
For example:
Alpha-Banking-Work-LoanApplication
↑
Alpha-Banking-Work
↑
Alpha-Banking
Because the classes share the appropriate class-name prefix, Pega can follow the pattern inheritance hierarchy.
Pega Academy describes Pattern Inheritance as automatic and based on class-name structure.
4. What is Directed Inheritance?
Interview Answer
Directed Inheritance is explicit inheritance where the parent class is specified directly on the class definition.
It is particularly useful when the class needs to inherit from a class outside its normal naming pattern, such as standard Pega classes or classes belonging to another application.
For example:
Alpha-Banking-Work-LoanApplication
|
| Directed inheritance
↓
Work-Cover-
The parent is explicitly configured rather than inferred from the class-name prefix.
Pega Academy specifically identifies Directed Inheritance as the mechanism used to reuse rules from standard Pega classes or classes outside the normal business class hierarchy.
5. What is the difference between Pattern and Directed Inheritance?
| Pattern Inheritance | Directed Inheritance |
|---|---|
| Automatic | Explicit |
| Based on class naming structure | Parent class explicitly specified |
| Usually within business/class hierarchy | Useful across application/class boundaries |
| Promotes business-level reuse | Promotes functional/platform reuse |
| Example: Alpha-Banking-Work → LoanApplication | Example: LoanApplication → Work-Cover- |
Pega's inheritance algorithm first follows Pattern Inheritance and then uses the Directed Inheritance parent as the starting point for another Pattern Inheritance search.
6. Explain the Pattern Inheritance hierarchy for Alpha-Banking-Work-LoanApplication.
Interview Answer
Assume the following class structure:
Alpha-Banking-Work-LoanApplication
↑
Alpha-Banking-Work
↑
Alpha-Banking
↑
@baseclass
When Pega needs a rule for the LoanApplication Case, it first considers the current class and then searches the appropriate parent classes through Pattern Inheritance.
A more complete architecture could be:
Most specific banking Case class
Common banking work rules
Organization/application-level reusable rules
Ultimate base class
7. What happens when a rule is not found in the immediate class?
Interview Answer
Pega continues the inheritance search.
For Alpha-Banking-Work-LoanApplication, it looks at the appropriate parent class through Pattern Inheritance.
If the rule is not found there, the search continues upward.
LoanApplication
↓
Alpha-Banking-Work
↓
Alpha-Banking
↓
Directed parent, if applicable
↓
Pattern hierarchy of directed parent
↓
...
↓
@baseclass
Pega Academy explicitly describes this alternating process: Pattern Inheritance is searched first, then the Directed Inheritance parent becomes the basis for another Pattern Inheritance search.
8. How does Pega search the class hierarchy?
Interview Answer
Pega searches from the most specific class upward through the inheritance hierarchy.
Conceptually:
Current Class
↓
Pattern Parent
↓
Pattern Parent
↓
Directed Parent
↓
Pattern Parent of Directed Parent
↓
...
↓
@baseclass
The important point is that Directed Inheritance does not simply mean "jump directly to the final rule." Pega uses the directed parent as the starting point for another inheritance search.
9. When does Directed Inheritance come into play?
Interview Answer
Directed Inheritance comes into play when Pega reaches the directed parent of the current class after exhausting the applicable Pattern Inheritance path.
For example:
Alpha-Banking-Work-LoanApplication
↓
Alpha-Banking-Work
↓
No rule found
↓
Directed parent = Work-Cover-
↓
Search Work-Cover- hierarchy
This is why understanding both inheritance mechanisms is important.
10. What happens after Pega follows a Directed Inheritance path?
Interview Answer
Pega starts another Pattern Inheritance search from the directed parent.
For example:
LoanApplication
↓
Alpha-Banking-Work
↓
Directed inheritance
↓
Work-Cover-
↓
Pattern inheritance
↓
Work-
↓
@baseclass
This is a common interview trap.
Directed Inheritance does not mean "only search this one class."
The directed class becomes another point from which the inheritance search continues.
Pega Academy's current inheritance example demonstrates exactly this pattern.
11. What is @baseclass?
Interview Answer
@baseclass is the ultimate base class in Pega's inheritance hierarchy.
When Pega reaches the end of the applicable inheritance paths, @baseclass is the final class it can search for inherited rules.
Conceptually:
LoanApplication
↓
Alpha-Banking-Work
↓
Work-Cover-
↓
Work-
↓
@baseclass
Pega Academy refers to @baseclass as the ultimate base class.
12. Why is @baseclass important?
Interview Answer
It is important because it represents the end of the inheritance search.
If Pega cannot find a required rule after searching the applicable hierarchy through @baseclass, the rule cannot be resolved.
It also provides a conceptual foundation for understanding Pega's universal rule reuse architecture.
13. What is the difference between class inheritance and Ruleset inheritance?
Interview Answer
They solve different problems.
Class inheritance determines which classes a rule can be inherited from.
Ruleset inheritance/stack behavior determines which Rulesets are available and their precedence during rule resolution.
| Class Hierarchy | Ruleset Stack |
|---|---|
| Answers: "Which classes are relevant?" | Answers: "Which Rulesets are available and in what precedence?" |
| Example: LoanApplication → Banking Work | Example: NexusLoan:01-01-10 above CommonBanking:01-01-05 |
| Structural/object-oriented reuse | Runtime rule execution context |
Pega Academy notes that Ruleset resolution is more coarse-grained than class resolution, while class specialization provides more precise differentiation.
14. What is the difference between class hierarchy and Ruleset stack?
Interview Answer
The class hierarchy describes inheritance between classes.
The Ruleset stack describes the Rulesets available to the current application/requestor and their execution precedence.
Class Hierarchy
LoanApplication
↑
Banking-Work
↑
Banking
Controls class-based reuse.
Ruleset Stack
NexusLoan NexusBanking CommonBanking PegaRULES
Controls Ruleset precedence.
The Ruleset list is assembled from the application's Built-On hierarchy and other runtime context, and Rulesets higher in the list have higher precedence.
15. What is an Application's Built-On hierarchy versus class inheritance?
Interview Answer
The Built-On hierarchy describes application dependencies.
Class inheritance describes class-to-class rule reuse.
They are related but they are not the same thing.
For example:
Application hierarchy:
Nexus Banking
↓
Alpha Common Banking
↓
Pega Platform
While the class hierarchy might be:
Alpha-Banking-Work-LoanApplication
↓
Alpha-Banking-Work
↓
Work-Cover-
↓
Work-
↓
@baseclass
Pega Academy describes application structure as a separate architectural concept from class inheritance, with applications able to be built on other applications and classes specialized through inheritance.
16. How would you create reusable rules at Alpha-Banking-Work?
Interview Answer
I would place a rule at Alpha-Banking-Work when the rule represents common banking Case behavior that should be reused by multiple child Case Types.
Examples:
- Common customer validation
- Common banking Case initialization
- Common audit behavior
- Common error handling
- Common Case-level Data Transforms
- Common decision logic
For example:
Alpha-Banking-Work
|
+-- ValidateCustomer
+-- InitializeBankingCase
+-- CalculateCustomerRisk
+-- CommonCaseValidation
The principle is simple: put a rule at the highest class where it is genuinely reusable.
Current Pega Academy guidance explicitly recommends setting reusable rules in a higher parent class to avoid duplicate rules.
17. How would CustomerOnboarding inherit those rules?
Interview Answer
If CustomerOnboarding is implemented as:
Alpha-Banking-Work-CustomerOnboarding
and its parent is:
Alpha-Banking-Work
then Pattern Inheritance makes the rules in the parent available to the child, subject to normal rule resolution.
For example:
Rule: ValidateCustomer Defined in: Alpha-Banking-Work Referenced from: Alpha-Banking-Work-CustomerOnboarding Result: Parent rule can be reused.
18. How would LoanApplication override a common banking rule?
Interview Answer
I would create a more specific version of the same rule in the LoanApplication class when the loan process genuinely requires specialized behavior.
For example:
Parent:
Alpha-Banking-Work
ValidateCustomer
Child:
Alpha-Banking-Work-LoanApplication
ValidateCustomer
The child-class version is more specific in the class hierarchy and can specialize the common rule.
Pega Academy identifies class specialization as a powerful reuse mechanism and states that derived classes can override rules inherited from parent classes.
19. How does Pega decide which version of a rule to use?
Interview Answer
This is where Rule Resolution comes into play.
Pega considers several inputs, including:
- Rule type
- Rule name
- Apply To class
- Ruleset stack
- Class hierarchy
- Circumstances
- Date/time conditions
- Availability
- Access roles
- Privileges
Pega Academy's current Rule Resolution guidance explicitly lists the Ruleset list, class hierarchy, circumstances, availability, and user access roles/privileges among the inputs.
20. Why is Pega using this rule?
Interview Answer
I would answer this by walking through Rule Resolution rather than guessing based only on the rule's name.
I would check:
- What is the referenced rule name?
- What is the rule type?
- What is the current Apply To class?
- What class hierarchy is applicable?
- What Rulesets are in the user's Ruleset stack?
- Are there multiple versions?
- Are there circumstances?
- Is the selected rule Available?
- Is it Blocked or Withdrawn?
- Does the user have the required privileges?
That is the difference between a developer saying "I think this rule is executing" and an architect explaining "I can demonstrate why this rule wins Rule Resolution."
21. What factors participate in rule resolution?
Interview Answer
The major inputs are:
| Factor | Purpose |
|---|---|
| Rule Type | Identifies the type of rule |
| Rule Name | Identifies the requested rule |
| Apply To Class | Defines the class context |
| Class Hierarchy | Determines class specificity |
| Ruleset Stack | Determines Ruleset availability/precedence |
| Circumstance | Specializes by property/date conditions |
| Availability | Determines whether the candidate can run |
| Roles/Privileges | Determines authorization |
Pega's current Rule Resolution documentation lists these factors as inputs to the algorithm.
22. How does Ruleset precedence affect rule resolution?
Interview Answer
The Ruleset stack determines which Rulesets are available to the current runtime context and their precedence.
For example:
1. NexusLoan 2. NexusBanking 3. AlphaCommonBanking 4. PegaRULES
The order matters.
Pega Academy states that Rulesets at the top of the Ruleset list have higher precedence.
However, an important senior-level point is:
Class specificity is also a major part of rule resolution. Pega Academy's rule-candidate ranking identifies Class first and Ruleset second in the ranking sequence, followed by circumstance-related criteria and version.
23. How does class specificity affect rule resolution?
Interview Answer
A rule candidate defined closer to the referenced class is generally more specific than one inherited from a more distant parent.
For example:
LoanApplication
↑
Alpha-Banking-Work
If both classes contain a rule with the same purpose, the rule defined in the more specific class can be the stronger class match.
Pega Academy's ranking guidance identifies class as the first sorting criterion for remaining rule candidates.
24. What happens if the same rule exists in a parent and child class?
Interview Answer
Pega has two candidate rules with the same purpose but different Apply To classes.
For example:
Alpha-Banking-Work
ValidateLoan
Alpha-Banking-Work-LoanApplication
ValidateLoan
The child-class rule is more specific to LoanApplication and therefore can specialize the parent rule.
The exact winning candidate still depends on the complete Rule Resolution context, including Ruleset and other qualification factors.
25. Does the child rule always win?
Interview Answer
No. I would not say "the child always wins."
The child class provides a more specific class candidate, but Rule Resolution evaluates multiple factors.
For example, you also have to consider:
- Ruleset stack
- Rule version
- Circumstances
- Date/time qualifications
- Availability
- Privileges
Pega's current Rule Resolution documentation describes the algorithm as selecting the first rule that satisfies the relevant criteria rather than applying a simplistic child-always-wins rule.
26. How do Availability and Circumstances affect rule resolution?
Interview Answer
Availability determines whether a rule candidate can participate in resolution, while Circumstances allow Pega to specialize a rule based on conditions such as property values or dates.
Pega supports availability values including:
- Available
- Final
- Not Available
- Blocked
- Withdrawn
Current Pega Academy guidance documents these five availability states.
Example
Suppose we have:
ValidateLoan ``` Default ``` and:ValidateLoan Circumstance: .LoanType = "Mortgage"When processing a Mortgage Case, the circumstance can qualify the specialized version.
Pega Academy notes that circumstance resolution occurs after class and Ruleset resolution.
27. What are Access Roles and Privileges doing in Rule Resolution?
Interview Answer
Privileges are used to control whether the current user is authorized to execute a selected rule that requires a privilege.
This is important because authorization is not simply another way to select a different rule.
If Pega has selected a rule and the user lacks its required privilege, Pega can return an authorization error rather than simply selecting another rule.
Pega Academy states that privileges are considered after the candidate has been added to the Rules cache, and lack of the required privilege results in an error rather than selecting a different version.
28. What happens if a rule is Blocked?
Interview Answer
A Blocked rule can participate in Rule Resolution, but if it is selected, execution stops and Pega reports an error.
This is different from Not Available.
| Availability | Effect |
|---|---|
| Available | Can run |
| Final | Can run, but cannot be overridden/copied in the normal manner |
| Not Available | Not considered for execution |
| Blocked | If selected, execution stops with an error |
| Withdrawn | Hides the applicable rule candidates according to Pega's withdrawal behavior |
Pega Academy documents these availability behaviors explicitly.
29. What is the difference between Not Available, Blocked and Withdrawn?
Interview Answer
This is a good interview follow-up.
- Not Available: the candidate is not used for rule execution; another eligible candidate may be considered.
- Blocked: the candidate can be selected, but execution stops with an error.
- Withdrawn: the rule is effectively removed from consideration along with applicable same-purpose rules in the relevant lower/equal versions, causing Pega to continue looking elsewhere according to the withdrawal rules.
Pega Academy's current availability documentation describes these distinctions.
30. How do you troubleshoot an unexpected rule being executed?
Interview Answer
I don't immediately change the rule.
I first determine why Rule Resolution selected it.
My troubleshooting checklist is:
- Identify the exact rule type and rule name.
- Identify the current Apply To class.
- Inspect the class hierarchy.
- Inspect Pattern and Directed Inheritance.
- Inspect the user's Access Group.
- Inspect the Ruleset stack.
- Search for sibling rules with the same name.
- Check Ruleset versions.
- Check rule Availability.
- Check circumstances.
- Check date/time conditions.
- Check required privileges.
- Use Tracer/logging/developer tools to confirm runtime behavior.
Pega's Rule form also provides Actions → View Siblings, which is useful for finding other rules with the same name that Rule Resolution might select.
31. How would you troubleshoot a rule resolution problem?
Interview Answer
I use a structured top-down approach.
Step 1 — Identify the requested rule
Determine:
Rule Type Rule Name Apply To Class
Step 2 — Check the class hierarchy
LoanApplication
↓
Banking-Work
↓
Directed Parent
↓
...
Step 3 — Check the Ruleset stack
NexusLoan NexusBanking CommonBanking PegaRULES
Step 4 — Find candidate rules
Search by rule name and inspect sibling rules.
Step 5 — Check availability
Look for Available, Not Available, Blocked, Withdrawn, or Final.
Step 6 — Check specialization
Check circumstances and date/time conditions.
Step 7 — Check security
Verify Access Group, roles and privileges.
Step 8 — Confirm at runtime
Use Tracer and runtime diagnostics rather than relying only on what the App Explorer appears to show.
32. How do you use Tracer to investigate rule resolution?
Interview Answer
I use Tracer when I need to understand what actually happened at runtime rather than what I expect to happen from the design.
My approach is:
- Open the Case or reproduce the problem in a controlled environment.
- Start Tracer from Dev Studio.
- Enable the relevant tracing events for the investigation.
- Perform the action that causes the unexpected behavior.
- Inspect the trace for the rule execution path.
- Identify the rule class, rule type and rule name involved.
- Compare the runtime rule with the expected rule.
- Then inspect inheritance, Ruleset precedence, circumstances, availability and privileges.
The important point is that Tracer is not a substitute for understanding Rule Resolution. It is a runtime investigation tool that helps confirm what actually executed.
"I use Tracer to confirm the runtime behavior, but I use the class hierarchy, Ruleset stack, rule candidates, availability, circumstances and security context to explain why Pega selected that rule."
How Pattern and Directed Inheritance Work Together
This is probably the most important diagram in this article.
Pega Academy's inheritance examples describe this same pattern: search the Pattern Inheritance path first, then use the Directed Inheritance parent as the starting point for another Pattern Inheritance search until the ultimate base class is reached.
Class Hierarchy vs Application Hierarchy vs Ruleset Stack
These three concepts are frequently confused during interviews.
| Concept | What it represents | Example |
|---|---|---|
| Class Hierarchy | Rule/class inheritance | LoanApplication → Banking-Work |
| Application Built-On | Application dependency/modular architecture | Nexus → Common Banking → Pega |
| Ruleset Stack | Runtime Ruleset availability and precedence | NexusLoan → NexusBanking → Common |
Pega's application structure guidance treats application layering and class inheritance as related but distinct architectural mechanisms.
Rule Resolution — The Complete Mental Model
When an interviewer asks:
Think about the process in this order:
Rule Requested
↓
Rule Type + Rule Name + Apply To
↓
Rules Cache
↓
Candidate Rules
↓
Ruleset Availability
↓
Class Hierarchy
↓
Class Specificity
↓
Ruleset Precedence
↓
Circumstance / Date
↓
Rule Version
↓
Availability
↓
Authorization / Privilege
↓
Selected Rule
Pega's current Rule Resolution documentation describes the Rules Cache as a key part of runtime resolution and explains that candidate rules are filtered and ranked before the final rule is selected.
Important Rule Resolution Ranking
For senior interviews, remember the current documented candidate sorting sequence:
- Class
- Ruleset
- Circumstance
- Circumstance Date
- Date/Time Range
- Version
Pega Academy documents this ordering for the remaining rule candidates after filtering.
Avoid saying simply "Pega always chooses the highest version."
That is incomplete. Version is one of the later ranking criteria. Class and Ruleset are considered before version, and circumstances and availability can affect the result.
Real Alpha Bank Example — Why Is This Rule Running?
Suppose the LoanApplication Case executes a Data Transform named:
InitializeCustomer
You find two versions:
| Apply To | Ruleset | Version |
|---|---|---|
| Alpha-Banking-Work | AlphaBanking | 01-01-10 |
| Alpha-Banking-Work-LoanApplication | AlphaBanking | 01-01-05 |
A junior developer might say:
That is not a safe explanation.
The class-specific candidate is closer to the referenced class, and Pega's documented ranking starts with class before Ruleset, circumstance and version.
The correct approach is to evaluate the complete candidate set through Rule Resolution.
Real Alpha Bank Example — Common Rule and Specialized Rule
Suppose Alpha Bank has a common decision:
CalculateCustomerRisk
At the parent class:
Alpha-Banking-Work
The common implementation is:
Risk = Low if customer has no adverse history
LoanApplication needs additional loan-specific criteria.
So we specialize the rule:
Alpha-Banking-Work-LoanApplication
CalculateCustomerRisk
Now the LoanApplication Case can use the specialized implementation while other Case Types continue using the common implementation.
This is a clean example of class specialization and reuse.
Common Inheritance Architecture Mistakes
1. Putting everything in the Case Type class
This creates duplication.
2. Putting everything in the parent class
This creates an overly generic parent that becomes difficult to maintain.
3. Creating unnecessary Directed Inheritance
Directed inheritance should have a clear architectural reason.
4. Treating Rulesets as classes
Rulesets and classes solve different architectural problems.
5. Assuming highest version always wins
Rule Resolution considers multiple ranking factors.
6. Ignoring Availability
Blocked, Withdrawn and Not Available rules behave differently.
7. Ignoring security
A rule requiring a privilege can fail authorization even when it is otherwise the selected candidate.
8. Debugging only from App Explorer
Runtime Rule Resolution can involve the Ruleset stack, class hierarchy, circumstances, availability and security context.
Senior Pega Architect Interview Framework
If the interviewer gives you a rule-resolution problem, answer using this framework:
1. Identify the rule
Rule Type + Rule Name + Apply To Class
2. Identify the inheritance path
Pattern → Directed → Pattern → Directed → ...
3. Identify the Ruleset stack
Which Rulesets are available and what is their precedence?
4. Identify candidate rules
Look for same-purpose rules and sibling rules.
5. Check specialization
Circumstance, date/time conditions.
6. Check availability
Available / Final / Not Available / Blocked / Withdrawn.
7. Check authorization
Access Group, roles and privileges.
8. Confirm runtime behavior
Use Tracer and other runtime diagnostics.
30-Second Interview Answer
"In Pega, I use inheritance to maximize rule reuse and specialization. Pattern Inheritance is automatic and follows the class naming hierarchy, while Directed Inheritance explicitly points a class to another parent outside that normal pattern.
For Alpha Bank, I would keep common banking rules in Alpha-Banking-Work and specialize them in Case-specific classes such as Alpha-Banking-Work-LoanApplication.
At runtime, Rule Resolution determines which rule instance to execute. It considers the rule keys, Ruleset stack, class hierarchy, circumstances, availability, and user authorization. Class and Ruleset are important ranking factors, followed by circumstance and version-related criteria.
If an unexpected rule executes, I inspect the class hierarchy, Ruleset stack, sibling rules, availability, circumstances and privileges, and then use Tracer to confirm the runtime behavior."
Quick Interview Cheat Sheet
| Question | Short Answer |
|---|---|
| Pattern Inheritance? | Automatic inheritance based on class-name pattern. |
| Directed Inheritance? | Explicitly specified parent class. |
| @baseclass? | Ultimate base class. |
| Class hierarchy? | Defines class-based rule reuse. |
| Ruleset stack? | Defines runtime Ruleset availability and precedence. |
| Application Built-On? | Defines application dependencies/modular architecture. |
| Rule Resolution? | Determines the most appropriate rule instance to execute. |
| Child always wins? | No. Multiple Rule Resolution factors apply. |
| Highest version always wins? | No. Version is one of several ranking factors. |
| Blocked? | If selected, execution stops with an error. |
| Not Available? | Not used for execution. |
| Withdrawn? | Removes applicable rule candidates according to withdrawal behavior. |
| How troubleshoot? | Class hierarchy → Ruleset stack → candidates → circumstances → availability → privileges → Tracer. |
Final Takeaway
The easiest way to remember Pega Inheritance Architecture is:
Rule Resolution tells Pega which rule should execute.
For Alpha Bank:
Alpha-Banking-Work-LoanApplication
↓
Pattern Inheritance
↓
Alpha-Banking-Work
↓
Pattern Inheritance
↓
Alpha-Banking
↓
Directed Inheritance
↓
Work-Cover-
↓
Pattern Inheritance
↓
Work-
↓
@baseclass
Then Rule Resolution considers the applicable candidates using the runtime context:
Rule Type + Rule Name + Apply To Class + Class Hierarchy + Ruleset Stack + Circumstance + Availability + Version + Authorization ↓ Selected Rule
This is the level of explanation expected when discussing inheritance with a Senior Pega Developer, Lead System Architect, or Principal Applications Engineer interviewer.
References
- Pega Academy — Rule reuse through inheritance
- Pega Academy — Rule Resolution
- Pega Academy — The Rule Resolution Process
- Pega Academy — Rule Resolution Process and Rule Availability
- Pega Academy — Remaining Rule Candidates and Ranking
- Pega Academy — Ruleset List
- Pega Academy — Ruleset, Class, and Circumstance Specialization
- Pega Academy — Application Structure
- Pega Academy — Role-Based Access Control
Pega terminology, class structures, and configuration screens can vary by Pega Platform version and application architecture. The examples in this article use Alpha Bank and Nexus as fictional examples for interview preparation.
Powered by PegaHelp.com
No comments:
Post a Comment