Pega Interview Questions Scenario Based, With Answers

The Pega questions interviewers build scenarios around: rule resolution, data pages, SLAs, queue processors, debugging, CDH and Constellation.

Most Pega interview questions scenario based rounds use come back to a few mechanics: how Pega picks a rule, how data reaches a case, how work is routed and timed, how background work runs, and how you find out why something is slow. Decisioning roles add Customer Decision Hub (CDH) engagement policies and arbitration; newer roles ask about Constellation and Pega GenAI. Below: what Pega's exams weight most, 12 questions with short answers, a worked scenario answer and a one-week plan.

What Pega's exams say gets tested

The certification blueprints are the closest public list of what Pega expects a developer or decisioning consultant to know. Current versions on Pega Academy:

• Certified System Architect (Pega Platform '25) — Weight — Certified Decisioning Consultant (CDH '26) — Weight
• Case Management — 25% — Engagement policies — 15%
• Data and Integration — 20% — Decision strategies — 15%
• Application Development — 15% — Business agility in 1:1 customer engagement — 15%
• Security — 10% — Contact policy and volume constraints — 13%
• User Experience — 10% — Next-Best-Action concepts — 12%
• Pega GenAI — 10% — Actions and treatments — 12%
• DevOps — 5% — Channels — 10%
• Insights — 5% — AI and arbitration — 8%

Pega GenAI is a tenth of the system architect exam, so expect a GenAI question. And engagement policies carry almost twice the weight of arbitration, so prepare them as carefully as the P×C×V×L formula.

Core platform

1. Two versions of a rule exist and the wrong one runs. How does Pega choose?

Tests: rule resolution. Pega Academy describes four steps: gather every candidate from the rules cache; pick the first, best match (an exact property or date circumstance match, else the default rule; two equally valid matches produce a duplicate-rule error); check the rule is not Blocked; check the user has the privileges it requires. In the scenario, walk those steps and say what you would look for at each, such as an unexpected circumstanced version.

2. What is the difference between pattern and directed inheritance?

Pattern inheritance is automatic and follows the class name prefix. Directed inheritance names the parent explicitly on the class rule, which is how an application class reuses standard classes such as Work- or Data-. The detail that earns marks: Pega searches pattern-inherited parents first and goes to the directed parent only if the rule is not found.

3. Which data page scope would you use, and when does it reload?

Tests: scope as a design decision. Thread gives each case its own copy, so one case cannot read data loaded for another; Requestor is shared across one user or system session; Node is one copy for everyone. A country list is Node, a user's preferences are Requestor, a customer's account details for this claim are Thread. Data pages load only when accessed. Know the refresh options: reload once per interaction (Thread and Requestor only, not combinable with the others), reload if older than an interval, and do not reload when a condition is true. Pega never refreshes a data page more than once per interaction. Edit modes add depth: read-only, editable, savable.

Workflow and timing

4. How would you route an assignment so anyone on a team can take it, but some cases go to specialists?

A worklist holds one user's open assignments; a work queue holds them for a group. Route to a work queue when anyone in the work group can do the task, and use business logic for conditions, as in Academy's example sending quotes with the RV box ticked to an RV underwriters queue. You may still hear "workbasket"; current Academy material says work queue.

5. An assignment must escalate to a manager if nobody finishes it within two days. Configure it.

Tests: SLA vocabulary. A service-level agreement has a goal (the target, measured from the start), a deadline (after which the work is late) and a passed-deadline interval (measured from the deadline, repeatable). Urgency runs from 0 to 100; higher-urgency work is handled first. A missed interval can trigger escalations, such as reassigning to another user or work queue or resolving the case, and notify the assignee, their manager or case participants. Here: a two-day deadline, an escalation that reassigns to the manager, and a notification explaining why.

Background processing

6. Agents, queue processors or job schedulers: which would you use?

Queue processors replace standard agents; job schedulers replace advanced agents. Agents polled the database for work, which caused contention as data grew; a queue processor pushes each item to a Kafka topic as soon as the work is created. Job schedulers handle recurring, clock-driven tasks. Sending a confirmation when a case resolves is queue processor work; a nightly summary is a job scheduler.

Debugging and performance

7. A case fails at a later step than the one that caused it. How do you find the cause?

The Clipboard shows current property values; the Tracer logs the sequence of events. An error often shows only the last step in a chain of failures, so reading the Tracer sequence backwards helps find the root cause. Note the cost: Tracer slows the application significantly, so it is not a performance tool.

8. A screen takes eight seconds in production. Walk me through it.

Start with the Performance Analyzer (PAL), which summarises the resources one requestor session used without slowing processing; take a baseline before changing anything. If PAL points at the database, run Database Trace. Run the Performance Profiler alongside PAL to find the specific activity, when condition or data transform. Then rule out a data page that reloads every interaction from a slow REST call.

9. A report definition stops at 500 rows. Why?

A row limit caps it. In a Pega Community thread, one answer traces the 500 to the pyMaxRecords setting, while others quote documentation saying a blank field means a 10,000-row limit. Name where the limit lives (the report's 'Max no. of rows to retrieve' field and the pyMaxRecords setting), check it on your version, and ask whether the user needs every row.

Integration

10. Load a data page from an external REST service.

In the Academy example, the REST Integration wizard creates the connector and a class for the response. A data transform maps that class onto your data class, and the data page's load activity calls the connector and applies the transform. Add what happens when the service fails, and which scope the page should have.

Decisioning (CDH)

11. How does Customer Decision Hub choose the next best action?

Engagement policies come first: eligibility (can the customer have this action at all), applicability (does it fit their current situation) and suitability (is it appropriate for them). Surviving actions go to arbitration, which multiplies propensity, context weighting, business value and business levers (P×C×V×L) into a priority; the highest is presented. Propensity, the predicted likelihood of a positive response, is calculated by AI. A scenario like "a customer just complained; which actions should disappear?" is a policy question, not an arbitration one.

Constellation and GenAI

12. What changes with Constellation, and what is Blueprint?

Constellation moves UI work from customisation to configuration: a React-based design system, single-page apps, and views instead of harnesses and sections. Its DX API serves both Pega's own UI and custom front ends. Academy says it works best for new applications and the traditional architecture for existing ones, which is the migration trade-off. Pega GenAI Blueprint generates case types, life cycles, data models, data objects and personas from an application description, on Pega.com.

A scenario answer, worked through

This example is illustrative. Prompt: "Claims sit in the adjusters' queue for days, and the claim screen is slow. What do you do?"

A weak answer lists tools: "I'd check the logs, use Tracer, and add an SLA." A stronger one separates the two problems and orders the steps:

1. Clarify. How long may a claim wait, and who is told when it waits too long? That sets the SLA.
2. Fix the waiting. Add an SLA whose deadline escalation reassigns the claim to a supervisor's queue and notifies the supervisor.
3. Measure the slowness. Baseline with PAL, then Database Trace or the Profiler depending on what PAL shows. Tracer follows logic; it does not time it.
4. Check the data design. If a data page reloads policy data from a REST connector every interaction, change its refresh strategy and confirm with a second PAL reading.

Each step says what you expect to learn and what you would change. That is the difference.

A one-week plan

• Days 1–3: Questions 1–10, answered aloud without notes, saying what you would check first and why.
• Day 4: CDH or Constellation, whichever the job post mentions.
• Day 5: Write two scenario answers from your own projects: clarify, fix, measure, confirm.
• Day 6: Rehearse aloud with follow-up questions. Verve AI's mock interview has an AI recruiter ask questions from a bank you choose, including your own saved Pega questions, then gives a scored feedback report.

See also our technical round interview questions and, for other enterprise platforms, Salesforce developer interview questions and ServiceNow IRM architect questions.

Sources

• Rule resolution steps: https://academy.pega.com/topic/rule-resolution-process/v2
• Pattern and directed inheritance, search order: https://academy.pega.com/node/24281
• Data page scope, loading and edit modes: https://academy.pega.com/topic/data-pages/v6
• Data page refresh strategy options: https://academy.pega.com/node/67601
• Worklists, work queues and routing by business logic: https://academy.pega.com/node/61581
• SLA goal, deadline, passed deadline, urgency, escalation and notifications: https://academy.pega.com/node/80721
• Queue processors and job schedulers replacing agents; Kafka push model: https://academy.pega.com/node/100811
• Tracer vs Clipboard, Tracer performance impact: https://academy.pega.com/node/38141
• PAL, Database Trace and Performance Profiler: https://academy.pega.com/topic/performance-testing-tools/v5
• Report definition row limit (500 vs 10K, pyMaxRecords): https://forums.pega.com/t/default-maximum-number-of-rows-to-retrieve-in-report/6410
• REST connector feeding a data page: https://academy.pega.com/topic/external-data-source-example/v1
• Engagement policies and arbitration (P×C×V×L): https://academy.pega.com/topic/action-arbitration/v3
• Constellation built on React, SPAs, DX API, configuration over customisation: https://academy.pega.com/node/70321
• Constellation views instead of harnesses and sections; best for new applications: https://academy.pega.com/node/49731
• Pega GenAI Blueprint outputs and availability: https://academy.pega.com/node/84551
• Certified System Architect '25 exam topics and weights: https://academy.pega.com/node/101441
• Certified Decisioning Consultant (CDH '26) exam topics and weights: https://academy.pega.com/exam/certified-pega-decisioning-consultant-6
• Verve AI Mock Interview: https://docs.vervecopilot.com/features/mock-interview