Pega Infinity Development Best Practices

Pega Infinity Development Best Practices

Description	Guidelines for Pega Platform developers to create efficient, sustainable, and guardrail-compliant applications
Version as of	8.5
Application	Pega Platform
Capability/Industry Area	Enterprise Application Development

This document provides application development best practices for Pega Platform™ developers to create efficient, sustainable, and guardrail-compliant applications. We collated and consolidated the following list of best practices from the development experiences shared by lead system architects, consultants, and development teams.

The following list of Pega Infinity development best practices is sorted by impact category and then by severity if developers do not follow guidelines. You can click the table headers to sort the list by rule type or impact category. Note that this list excludes Cosmos development best practices. When new best practices are encountered, this list will be updated to capture the new information.

Rule type	Impact Category	Best Practice	Severity
UI rules	Update	Non-Autogenerated, custom, or hand-coded rules are not likely to be cross-browser-compliant or responsive. Move to autogenerated UI components for better performance, security, ease of maintenance, and support for cross-browser consistency/responsiveness. Replace custom JavaScript, HTML, JSP, and other code with standard features available in Pega Infinity. Do not create non-autogenerated records, such as sections, HTML rules, HTML fragments, and text files. All screens should be generated for JSP (including Rule-HTML-Property, Rule-HTML-Fragment, and Rule-Obj-HTML).	H
UI rules	Update	Pega Infinity has controls that support new features, such as offline capability, responsiveness, and cross-browser support. Deprecated or custom controls do not have these capabilities, so you should update to controls shipped with Pega Infinity. Replace custom or deprecated controls with the latest Pega Infinity controls. If no updated control is available, make custom controls cross-browser and responsive.	H
UI rules	Update	Pega Infinity recommends the skin rule for all styling needs in the application. This reduces maintenance cost and provides flexibility to style consistently, regardless of browser or device. Make applications cross-browser and cross-device-compliant. Inline styles and custom CSS must be re-engineered using Pega Infinity skin, mixins, and style formats.	H
Data pages	Update	Do not remove parameters for a data page. Never remove parameters from shipped data pages in the framework layer. The implementation layer might use your data pages with Key,Value; removing a parameter might make referenced rules invalid, causing exceptions in flows.	H
Reports	Update	Do not remove properties from report definitions when they are declared as available, especially in the framework layer. Never remove properties from report definitions that are shipped, even if those properties are not being used. If the implementation layer attempts to re-use a report definition for which properties have been removed, it will impact the referencing rules.	H
Data pages	Update	Avoid adding required parameters to old rules. Avoid adding new required parameters to shipped data pages in framework layer. The implemention layer might use these data pages, and adding new parameters might make their referenced rules invalid, causing exceptions in flows.	H
All rules	Update	Do not block the availability rules in the framework layer.	H
All rules	Update	Replace deprecated rules references with recommended/available rules. Do not use deprecated activity methods.	H
All rules	Update	Do not reference internal Pega rules in implementations.	H
All rules	Update	The use of locatable pages was deprecated in Pega Platform as of the 7.3.1 release. Locatable pages are a legacy feature that is not supported by the Internal Language (IL) assembly. Using locatable pages would require falling back to legacy assemblers that would not utilize the IL assembly optimizations.	H
All rules	Update	Use extensions wherever provided instead of overriding rules. Use Pega rules as-is and append new functionality in your application rules.	H
Ruleset	Update	Only application ruleset validation (ABV) is recommended for ruleset setting.	M
All rules	Update	Pega Infinity has been enhanced with more guardrails and validations and with better coding standards. Some legacy features are no longer supported and must be modified to Pega Infinity standards. Update references such as $ANY or $NONE with appropriate class references.	M
Data types	Update	Pega Infinity has updated Data Management/Modeling features that provide better design and runtime performance. Update these components to new features. There are no auto-update utilities for most of the features in this area. Update old data tables to the new local storage data types to comply with Pega Infinity standards.	M
Portal	Update	Legacy fixed or custom portals are no longer recommended in Pega Infinity, as they do not support cross-browser or responsive design. Debugging tools such as Live UI might not work for these legacy portals. Replace fixed or custom portals that lack responsiveness with Pega Infinity composite portals.	L
Delegated rules	Update	Delegated rules will continue to work after you update to Pega Infinity, but they might need updates to address changes to referencing rules and form changes. Skimming is recommended during update, which might require delegation re-mapping. Rule form changes require business retraining. Update delegated rules wherever required.	L
Reports	Performance	Fetch only the required columns and not all columns from the database.	H
Reports	Performance	Avoid unnecessary JOINS while fetching database records.	H
Activity	Performance	Use data pages backup by RD or Look up rather than using obj-browse. Do not use obj-browse for list of objects. If you use obj-browse, fetch only the column you need and not the entire BLOB. If some BLOB data is used frequently, consider exposing that column.	H
UI rules	Performance	Consider using pagination of records for Memory / Performance optimization based on your specific use case requirements. Pagination should be enabled when fetching records from the database.	H
All rules	Performance	Use Alert logs, PAL, and Log Usage to monitor performance during development, UAT, and performance testing. If you observe performance issues, collaborate with performance tuning experts to resolve those issues. Assess performance load and verify the capacity of your production system.	H
Clipboard viewer	Performance	Identify and remove unnecessary clipboard pages at the end of each process. Redundant pages use JVM memory.	H
Reports	Performance	Verify that the report definition filters load only necessary data to the clipboard. Configuring filters correctly is better than using row visibility conditions to hide rows in a grid.	H
Decision tables	Performance	To avoid slow performance, limit your decision table to no more than 300-500 rows.	H
Decision trees	Performance	To avoid slow performance, limit your decision tree to no more than 300-500 rows.	H
Map values	Performance	To avoid slow performance, limit your decision map rules to no more than 300-500 rows.	H
Class	Performance	Ensure classes are not mapped to more than one purpose database table, such as pr_data or pr_other. Maintenance of exposed properties for more than one type of data prevents appropriate indexes from being used.	H
Rule-Obj-Activity	Performance	Always use Obj methods (rather than RDB methods) to ensure the BLOB and columns are kept in sync. RDB methods should be used only for complex query processing/connecting to an external database.	M
Activity	Performance	Max Records is not automatically specified on the RDB-List method. If the Max Records value is left blank, it defaults to 10,000. Consider specifying a maximum limit for improved query performance.	M
All rules	Performance	Debug Log (oLog) should be implemented properly in activities to debug and write warnings/errors in log files if an exception occurs. When logging log information externally, verify that logged information provides sufficient detail to assist in debugging an issue. By default, the application logs class name, activity name, step, date/time, requestor, and error type. Additional log items might include case ID, case status, and operator. Make sure you do not log sensitive information. Specify appropriate log level settings so that production logs and PDC are not cluttered. System.out.print should be removed or commented after development.	M
UI rules	Performance	Records fetched in memory should be just-in-time rather than persisted throughout the user session. Use appropriate data page scoping.	M
Activity	Performance	If you use a parameter with the OBJ-BROWSE method (to/from/like), define a pre-condition on the step to verify that all required parameters exist before the OBJ- BROWSE method is invoked.	M
Agent	Performance	Use queue processors or job schedulers instead of agents for better performance, resiliency, fault tolerance, and flexibility.	M
Class	Performance	Consider not storing the history of classes in environments where changes will be frequent and you have no business reason to track updates.	M
All rules	Performance	Avoid using large text values in top-level pages. Elastic search indexes all top-level properties when it is enabled on a class. Consider keeping large text values in embed page properties.	M
All rules	Performance	Use wrapper activity to consolidate actions and reduce the number of requests to the server.	M
UI rules	Performance	Enable defer load for tabs/section for faster screen loads. Load data just in time when the end user needs it.	M
UI rules	Performance	JPEG/PNG images should be used only when the image size is greater than 100 x 100 px. For smaller images, consider using Icon font so you avoid time-consuming requests to the server.	M
Data pages	Performance	Load mechanism is executed on every interaction for data page can impact performance. Select this option only when the business use case requires the freshest information.	M
Activity	Performance	Do not use the Infoforced log. Remove unnecessary log messages before check-in. Change the logging level to prevent cluttering of log files and avoid potential performance impact.	L
Data transforms	Performance	Enable "call super-class data transform" checks only if you have a data transform with the same name in the class inheritance tree. Doing so avoids the overhead of looking up to parent classes.	L
Access roles	Security	Implement custom security roles to maintain security requirements. End-user access groups should not grant the PegaRULES:SysAdm4 security role. Roles should default to having least privileges to end-user access groups.	H
Reports	Security	Add appropriate privileges and restrictions to reports to control which user groups can execute a report.	H
Activity	Security	"Allow direct invocation from the client or a service" or "Allow invocation from browser" is unchecked by default. If you enable the "Allow direct invocation from the client or a service" checkbox, you must add a privilege to the activity.	H
Workbasket	Security	Add the appropriate roles to workbasket definitions to control who can process assignments in the workbasket	M
Data pages	Security	Select an appropriate user-level access group for all node-level data pages. Create an access group used specifically for batch processing (data page loading and agent activity processing).	M
All rules	Maintainability	Reduce or eliminate use of duplicate loops in rules such as activity or data transform, which can have significant performance impact. 1. When possible, do as much processing as possible in one pass to avoid looping over the same data multiple times. . 2. When looping over a data structure, be aware that the larger the list, the more times processing will occur. For example, you can use a report definition "Class Join" feature to gather data in one database call rather than making separate database call for every result returned. If services are called within a loop, use data pages to cache results to improve overall performance.	H
Database	Maintainability	Do not use custom store procedures to accomplish a task.	H
Data transforms	Maintainability	Data transforms should not use the pxExecuteAnActivity function to call an activity. Evaluate whether the called activity can be transformed to a data transform.	H
Section	Maintainability	'Create work' action class input parameters should not be hard-coded. Consider using dynamic class referencing to improve maintenance and extensibility.	H
Flow	Maintainability	To create the implementation layer case type, select other option and use DCR to specify the class name rather than selecting the case type in create case smart shape.	H
All rules	Maintainability	Consider deprecating rules to post warnings on usage. Provide documentation on the deprecated rules.	H
All rules	Maintainability	Avoid creating custom-coded rules. If no better option is available, then ensure custom-coded rules, such as activities with java steps, non-autogenerated UI rules, and functions, are final.	H
Class	Maintainability	Consider enabling 'Propagate schema changes to child classes', for work classes to avoid explicit optimization at the customer end.	M
All rules	Maintainability	When creating a rule such as an activity or data transform, use parameters to clearly define the inputs and outputs so system architects understand how that activity is used. If the activity needs a specific value to process, rather than passing a complete page reference, pass a scalar parameter.	M
All rules	Maintainability	When creating a new rule that is similar to an existing rule, minimize duplicate code. If you are changing only values (but not changing the code) in a rule, refactor the rule to use parameters instead of creating multiple versions of the same rule. If the same code is used multiple times, create well-documented reusable assets that can be called from different places rather than copying that code. Determine the reusability of the rule, as this determines where the rule should be placed in the Class and RuleSet hierarchy.	M
All rules	Maintainability	Consider your rule's Applies-to class carefully. Put rules in a higher parent class if you anticipate reusing it across all children or if you want to avoid duplicate rules. If a rule is not reusable, put it in the class where it is used. Do not flood abstract classes with rules that can be used only in particular concrete classes. If a rule is needed in multiple concrete classes, do not copy the rule across to the sibling. Instead, promote the rule to the child class and withdraw the original rule to avoid duplicate code.	M
Activity	Maintainability	Do not use Page-New methods to create a page that you are planning to use as step page for Obj-Open/Obj-Browse/RDB-List/RDB-Open. These methods create the specified page by itself.	M
Activity	Maintainability	Do not use hard-coded reusable values in properties such as URL or classes (activity class etc) in activities. Rather, use data pages/decision tables/map values.	M
All rules	Maintainability	The name of a workbasket should clearly identify the purpose of the workbasket.	M
Flow	Maintainability	Business rule flow should be neat and readable, as it can be exposed to business users. Add annotation to improve readability.	M
Flow actions	Maintainability	Flow Action Name should describe the functions of the flow action. For example: AttachAFile, Notify External.	M
Flow	Maintainability	Utilities should serve a business purpose. Instead of adding one utility that does an entire step, separate the utility into separate smaller utilities, and use these smaller utilities as individual identity in the flows. This makes the flows descriptive and readable.	M
Flow	Maintainability	The number of Smart Shapes (excluding connectors) should not be more than 15 per work flow.	M
Flow	Maintainability	Flow implementation should be model-driven. For example, identify and use decision rules in a flow rather than an activity. This will make the logic of the flow clearer.	M
UI rules	Maintainability	When possible, set the label value for a control from the short description for its property rather than from inline labels, which increase maintenance costs.	M
Property	Maintainability	Do not duplicate properties if you can avoid it. 1. If multiple classes use a property, define the property once where it is accessible to all classes that need it. 2. If one of two classes that need to use the property do not share a parent (for instance, one is Embed- and the other is not), you can copy the property. Be sure to use the exact same name.	M
Property	Maintainability	Avoid copying data. 1. During processing, data should exist in only one place. In Pega, that means in a single property. 2. If user input has a cascading effect (setting a value in one place creates defaults for a number of other values), then you can copy data if the effect is one-directional. In other words, you can copy data only when you can define it using something like a declare expression. Verify that you do not create circular dependencies when you copy data.	M
Property	Maintainability	Property types should be selected from the type dropdown rather than specified in text.	M
All rules	Maintainability	Add test rules to a separate test application that is built on a target application.	M
All rules	Maintainability	Remove all unused rules before you move to production.	M
Activity	Maintainability	The Page-New method with an empty class initializes the page with the class defined in Pages and Classes. Consider using dynamic class referencing for easy maintenance and extensibility.	M
Flow actions	Maintainability	Use a validate rule to perform data validations, and invoke the same validate rule from the flow action. An activity doing the same in post processing using Obj-Validate or Property-Set-Messages does not support extensibility.	M
Navigation	Maintainability	Control action should not be configured using hard-coded class. Consider using dynamic class referencing for easy maintenance and extensibility.	M
Data transforms	Maintainability	Consider modularizing a data transform so that it does not require more than 20 steps. This improves reusability and unit-level quality.	M
UI rules	Maintainability	Use WHEN rules rather than expressions in section/layout/control visibility conditions if the same condition is used in multiple places for easy maintenance and extensibility.	M
Data transforms	Maintainability	Inline Java is always overhead in terms of maintenance. Consequently, consider using data page or data transform. RUF is recommended if unavoidable.	M
Section	Maintainability	When deciding whether to use a section or to nest a dynamic layout, minimize the number of sections that you create to improve performance and maintenance. Use a section if: You plan to use it in multiple places. Its contents must be refreshed from the server more often than the content around it. The data requires a table/grid layout but you want to include it in same layout as the rest of the UI to share a container format, style, or header.  Its content uses a different step page than the UI around it. In other cases, nest a dynamic layout.	M
Data transforms	Maintainability	Do not use more than five levels of nested steps in data transforms.	M
Declare-On Change	Maintainability	Do not use a Complex Java Expression under When condition in the Conditions field of the On Change Properties tab,	M
Activity	Maintainability	Use automation rules instead of activity rules when you create an API.	M
Activity	Maintainability	Give precedence to a local variable over a property if scope is defined only within the activity. If local variables are defined but are not being used in the activity, consider removing them.	L
Activity	Maintainability	Provide comments to describe the context of significant steps in an activity to improve readability and maintainability,	L
Activity	Maintainability	Comment out activity step lines to prevent them from executing at run time during testing. Commented lines should usually be removed before merging your rules. You may want to keep commented lines if they are helpful when debugging or if they help someone understand the activity,	L
All rules	Maintainability	Document your rules when the purpose or use of a rule is not clear to improve maintainability. Document what the rule does in the description and how the rule is used in Usage. The rule label should indicate the purpose of the rule in human-readable form.	L
Activity	Maintainability	Activity names should start with a verb/noun.	L
All rules	Maintainability	When defining parameters, select the appropriate data type and provide a meaningful description/purpose.	L
Activity	Maintainability	Activities should not exceed 20 steps.	L
Property	Maintainability	Property names should be based on nouns or noun phrases that describe the property.	L
Declare expressions	Maintainability	Adopt a naming convention for properties designed to be computed in Declare Expression rules. Create Declare Expression rules early, using stub or dummy expressions. By following naming conventions, developers can easily identify declare expression properties and can avoid setting values procedurally. The use of reference properties in an expression's target or page context can result in unpredictable behavior. Consider using non-referenced properties instead.	L
All rules	Maintainability	You must provide appropriate comments when checking in a rule after modification. Include a work item, such as a change request or error number, at the beginning of the description of the change. For example: "US-00001 – Removed pyWorkPage Page Delete Step from Activity."	L
Data transforms	Maintainability	Consider adding comments to the data transform for easier readability, maintenance, and potential reuse.	L
Data transforms	Maintainability	Data transforms should not have disabled steps under most circumstances. Review and remove disabled steps if they are not required.	L
Activity	Maintainability	If an Activity rule is required, set an appropriate 'Activity type’ in the Security tab to remove warnings. For example: "Utility (default), Validate, Load Data Page."	L
Data transforms	Maintainability	Avoid using (<APPEND>) (<CURRENT>) to improve readability. Consider using 'Append and map to'.	L
UI rules	Functionality	Do not use horizontal scrolling. Minimize vertical scrolling.	H
Property	Functionality	Use Date Time rather than Date or TimeOfDay types for properties that are part of persistent objects in your application. Avoid using Date property types in persistent objects, even if your application is used in only a single time zone, unless a time zone value is also stored in another property of the object.	H
Decision tree	Functionality	We cannot redirect a rule to itself under Circumstance Value in the Options field of the Results tab. Avoid creating a circular set of redirections (A to B and B to A) because this causes an exception at runtime.	H
Declare Trigger	Functionality	When there are multiple triggers on the same class(user defined/inherited), then the order in which the triggers fire is not guaranteed. Trigger activities should be implemented in a way where they are mutually exclusive and independent of each other in terms of functionality.	H
Map values	Functionality	We cannot redirect a rule to itself under Circumstance Value in the Options field of the Results tab. Avoid creating a circular set of redirections (A to B and B to A) because this causes an exception at runtime.	H
Activity	Functionality	When you use the History-Add method, use field values to support localizations.	M
Activity	Functionality	Use @equals functions instead of '==' for string comparisons.	M
Flow	Functionality	Always give the status of an assignment and the status of work in the assignment task parameters.	M
Flow	Functionality	Do not hardcode the workbasket/router user name In the routing unless it is important. Use a parameter page instead.	M
Flow	Functionality	Configure meaningful and readable audit information in a flow. For example, use a proper action description in the assignment task. Remember that whatever action comes in an assignment will be described in the work item history as “Assignment To” and the added text.	M
UI rules	Functionality	Don't use fixed widths. For table-style layouts such as grids or tree grids, always set the width to 100%. This allows the display to adapt to the device the viewer is using.	M
UI rules	Functionality	Make sure autogenerated controls have validation options.	M
UI rules	Functionality	Improve the user experience by removing unneeded clicks, especially for tasks that are simple or frequently repeated.	M
UI rules	Functionality	Use the field values for text displayed to users to support localization.	M
UI rules	Functionality	To ensure client validation is working, enable client validation on the harness.	M
UI rules	Functionality	'Localize' should be checked on Section rules.	M
Decision tables	Functionality	Specify the most likely outcome rows before you specify less likely outcome rows.	M
Declare-Index	Functionality	Do not create declarative indexes for top-level Single Value properties.	M
Rule-Utility-Function	Functionality	Use the String.Equals () or String.equalsIgnoreCase () Java method, not the == or != operators, to compare the value of a property to a literal string or to the value of another property.	M
Circumstance-Definition	Functionality	List the more likely outcomes in rows at the top of the table.	M
Circumstance-Definition	Maintainability	When circumstancing rules, use circumstance templates rather than circumstancing on properties to allow implementation layers to customize the templates.	M
Exception handling	Functionality	Database calls (and other integration calls) should be handled by incorporating preconditions and transitions related to errors and exceptions. “Jump To Later Step” / “Exit Activity” should be used effectively in activities to handle exceptions. Evaluate raising appropriate PDC alerts when errors occur. Usage of Obj-open, Obj-refresh-and-lock, Obj-open-by-handle, and Obj-Delete-by-handle requires the handling of lock acquisition failures. Obj-save and Commit should handle potential DB transaction errors. Connect- methods should handle the potential for connector failure. Not handling an error may result in ungraceful errors.	M
Exception handling	Functionality	Error Flow should be implemented in all critical use cases.	M
All rules	Functionality	Do not assume a clipboard page is available. Instead, perform appropriate verification checks before executing a data transform or activity.	M
Activity	Functionality	Do not use obj-save to save rules. Use "call pxUpdateRecord/pxCreateRecord" or "Call Save" instead.	M
Section	Functionality	Using Refresh When and Refresh Other Section. Use Refresh When whenever possible, especially for read-only references that need to remain synchronized with data on the server, as it declares dependencies ("This section needs to be updated when .x changes"). When this is not possible (for example, if you have editable references that are updated based on other input or based on untrackable inputs such as button clicks), use a Refresh Other Section targeted refresh.	M
Section	Functionality	Avoid Refresh section. Refreshes interrupt the user experience. The user has to wait, the screen seems to hang until the section refreshes, and after the refresh is done, the user has lost focus and has to manually return to the original screen. Manage client-side interactions by using change tracker whenever possible. For example, instead of refreshing a section with a pre-processing data transform, call a data transform or use set value and set your visibility conditionals to evaluate on client. Do refresh a section when: Property values have been updated on the server and the new values must be reflected in the UI. An action that causes a change to more than one property and that occurs only on the client, such as deleting a row, must be submitted. Parts of the UI must be removed from the DOM because of other input. Do not refresh a section when: You need to submit user input. Instead, use post value. You need to call a data transform or an activity after a user action. You need to recalculate visibility, enabled/disabled state, or read-only state. Select the evaluate on client check box next to the expression field. Judgment calls You have a complex expression to set visibility, enabled/disabled, or read-only state requiring a When condition. Consider using a declare expression to provide a value for a property and conditionalize on changes to that declare expression. You must handle style changes based on value changes. You must validate input and potentially show messages related to various properties. Note that validation provided by the controls, combined with a validate rule on the flow action, should cover most situations.	M
Section	Functionality	Use set value to set flags. Use case: you have a property .pyIsThingVisible. Put the property in a hidden input field in the UI and use "set value 'pyIsThingVisible = true" (or false). This is lighter weight than using "Run data transform pzSetIsThingVisible" (and creating and maintaining the data transform).	M
All rules	Functionality	Add Pega units for all the supported rule types.  Execute them during the development in branches and during the merge process. Look for 100% Unit Test passed before merging the branches.	M
Report-Definition	Functionality	Consider the use of the Smart Info capability to enrich the value of reports.	L
Data transform	Functionality	Avoid hardcoding pyWorkPage and pyWorkCover in data transforms and activities, as hard coding hampers the reuse of rules.	L
Activity	Functionality	In case of unavoidable scenarios, if Page-Change-Class Method is used, then you should use DCR pattern rather than a hard-coded class.	L
Flow	Functionality	As a best practice, use one of the following prefixes to support standard reports and maintain continuity in between your custom status and standard status values: New-, Open-, Pending-, or Resolved-	L
UI rules	Functionality	Avoid using icons for controls. Use link text or a button for clarity and ease of localization.	L
Section	Functionality	A general design/development approach should be that read-only display of a particular section is controlled outside of the section either through the harness in which it is included	L
UI rules	Functionality	Bundle your transactions in minimum calls (ex: call activity and refresh section can be bundled).	L
UI rules	Functionality	Input validation should happen on both the client and the server.	L

Reference

Understanding and complying with case management best practices

Configuring resources - use job schedulers and queue processors instead of agents

Pega Cloud Services update checklist for Pega Infinity release 8.4.2 and later

Pega Cloud Services update process for Pega Infinity release 8.4.2 and later

Locatable pages are deprecated

Developer best practices using Pega Platform

Securing an activity

Handling data page errors by using a data transform

Best practices for design templates

A business solution that automates workflows in your organization. Multiple, unrelated applications can be hosted in the same system. You create an application by running the New Application wizard.

The general classification or particular use of a rule. For example, the System screen in an application used for hiring employees contains Property rules that define the information that needs to be captured from the user, for example, full name, email address, phone number, and résumé. The screen also contains a Section or View rule that defines how the properties are displayed to the user.

Rules of different types are linked together to define your application. Rule types also help to categorize key concepts and behavior in your application, saving you time during the development cycle. You can use another instance of the same rule type to define other sections of the application.

The basic building blocks of an application, rules define the behavior of an application. There are many types of rules, each defining a different type of behavior. For example, rules define the display of a form, the fields that are used in your application, and the flows that define the process of completing work.

The system can reuse rules throughout your application. For example, in an application for ordering replacements parts, you can define a user interface to capture an address, and reuse the same rule for the UI to capture both the mailing address and the billing address for the order.

You define rules in an application to create a business solution for your organization and customers. Rules provide flexibility during the development process and help you design applications more efficiently, so that they can be implemented again in future projects.

An entity that models data in your business processes and defines what information you need to provide to reach your business goal. For example, in a process of hiring new employees, you can create properties that correspond to the personal details of a candidate, such as a name, a surname, and an address. Then, when you review applications from different candidates, you provide values specific to each candidate. To save time and make your application more relevant to customers, you can reference properties in different elements of your application, and then populate them with data at run time. For example, you can include a property that references a customer name in an email that your application sends automatically. As a result, each time that the email message is personalized and includes an actual customer name. Properties help you collect and provide consistent data irrespectively of the method in which users interact with your application. By referencing properties, you ensure that a user receives the same information through a website, an email, or a mobile app.

Text or HTML markup that is expected to have broad reuse. You can reference a fragment in the Include JSP tag to cause the system to incorporate the fragment rule into other HTML or correspondence rules as they are processed. A fragment is an instance of the Rule-HTML-Fragment rule type or the Rule-Corr-Fragment rule type.

Skins determine the general visual style of your interface and let you define the typography, placement, and appearance of UI elements. The skin separates content from presentation, so that you can reuse your configurations and keep a consistent UI design. For example, you can reuse a section anywhere in your application and retain a uniform style that is specific to your company.

A business solution that automates workflows in your organization. Multiple, unrelated applications can be hosted in the same system. You create an application by running the New Application wizard.

An entity that you use to cache data on demand to a clipboard page for use by one or more applications. A data page rule defines the source, scope, refresh strategy, editability, and structure of the cached data. Data pages were previously known as declare pages.

A layer that contains reusable application elements and provides an application that you can use as the basis for many production applications.

A layer that contains application elements that are specialized for a specific business audience or purpose. The contents of the implementation layer extend the elements of the framework to create a composite application that targets a specific organization or division.

(Pega Platform version 7.2.2. and later) A rule for creating advanced reports that show detailed information. Replace the Summary View Rule. A report definition rule provides more advanced options for displaying and managing data than the standard reports that you can create in App Studio.

A capability that you implement in your application. By defining features that are linked to rules and work items, you can improve the traceability of capabilities to their respective implementations.

A collection of rules (the basic building blocks of applications built with Pega Platform) that describe key components and how part of an application works. Rulesets help you store, categorize, and version the rules in an application.

A ruleset consists of ruleset versions that store the updated versions of rules. For example, in an application used for hiring new employees, the application might include several rulesets, one dedicated to defining the UI and processes used to hire employees, and another ruleset that defines the application's integration with a Job website.

You usually implement several rulesets when developing a large application. Once the rulesets are adequately tested and make it into a production environment, you can create a new version of the rulesets to develop and test during the next development cycle.

The container for the building blocks that define the behavior of your application. With application rulesets, you manage the versions of your application logic that are used to create the desired outcomes in your application. The order in which the system lists application rulesets on the application determines the priority of rules in that ruleset. For example, an application that is used for hiring new employees includes two rulesets, MyJobApp and MyHR, in that order. The system gives priority to rules that are located in MyJobApp over the rules located in MyHR because MyJobApp ruleset is first and MyHR is second in the list.

A setting that determines which elements in your application do not comply with Pega best practices. For example, guardrails typically flag custom components that require manual changes during upgrades. You must respond to guardrail warnings to ensure that your application meets the latest requirements for efficiency and ease of use, and save development time. By following the guardrails, you can secure a good compliance score. High compliance scores are a sign that the application is well-designed, efficient, and easy to expand.

An interface that provides users with an organized set of work tools. Users navigate the application, collaborate, and complete work assignments mainly through portals. Typically, you create a separate portal for each user group within your application. For example, you can create a portal for regular employees, and a separate one for their managers. Most portals contain a navigation menu that leads to various pages and dashboards, as well as a menu for creating new work items. Additionally, portals might also include widgets that improve work efficiency. For example, you can design a portal that has a widget for frequently used reports, which helps managers save time and oversee their projects.

A view of your data that displays information or collects input from users as they create, update, and resolve cases in your application. Open your case type from the Application Explorer to access the options for configuring a form.

The process of saving the highest version of a rule into a new, higher ruleset version. Skimming applies mainly to rule-resolved rules. The two types of skims are minor and major. During a minor skim, rules are stored in a higher minor version, and during a major skim, rules are stored in a higher major version.

The sequential processing unit in Pega Platform that consists of one or more steps. Each step can call a Pega Platform method, transfer control to another activity, or run custom inline Java.

User acceptance testing (UAT) is a methodology for testing specific business scenarios to ensure that a system behaves as the business expects.

The traditional tests of load, stress, soak, and scale. This testing type is typically performed by the client’s team.

A temporary memory area on the server that is associated with every connected Pega Platform requestor, including browser-based users and unauthenticated guest users. Your application uses information from the clipboard to process work and make decisions about the next action. For example, when a courier opens a delivery application to check the address of a customer, the system populates the address field in the application with the information stored in the clipboard. In this way, the clipboard acts as a temporary memory for your application and the case.

A table that consists of one or more rows that contain test conditions and a result to return. Evaluation proceeds from top to bottom; when the conditions in all cells in a row are true, the result of that row is returned. If no row returns a value, the table provides the Otherwise row result. Decision tables are instances of the Rule-Declare-DecisionTable class.

A rule that defines a series of tests on property values to allow an automated decision. Decision trees capture and present business logic in the form of one or more if/then/else conditions. Decision trees are instances of the Rule-Declare-DecisionTree class.

The rules that define the behavior of your application. You can create classes to gather rules related to a specific object in your application. For example, in a recruitment application, you can create a class that contains rules that define the flow of the recruitment process. Classes can contain other classes, hence a class that contains another class is called a parent class, while a class that is contained by another class is called a child class. A child class can reuse, or inherit, any of the rules that are defined for its parent class, which helps to build your application faster and more efficiently.

A Pega Platform method, distinct from a Java method. An operation that can be performed by one step of an activity ( Rule-Obj-Activity rule type), or by a Parse Structured rule ( Rule-Parse-Structured rule type).

The smallest element of your business process, a step represents a single task. A step can be a user action, such as collecting information from a customer, or an automation that an application performs, for example, sending an email to a customer when a business process reaches resolution. When you visualize your work, you order steps in a sequence that communicates what actions are required to reach your business objective. You can select from a wide choice of steps to ensure that you reach your goals in the most efficient way.

The process and data associated with a Pega Platform user (guest or authenticated). A requestor is also the processing and data associated with a request to your system started by an outside system, such as a web application server or an Active Server Page on a web site.

The primary indicator of the current state of your business process. By using case statuses, you communicate progress to people that are involved in case processing to ensure a common understanding on the path to reaching your business objectives.

For example, you can use a status In-Progress to communicate that a case worker is working on a case, and Resolved-Completed to announce that the case reached a successful resolution. You can use default statuses, or you can create custom statuses to meet your unique business needs.

An application user that is identified by the user name, password, and other details. Each operator has a role, such as caseworker or customer service representative, that determines what actions the user can perform.

An internal background process that operates on the server that runs activities on a periodic basis. In a multinode cluster, an agent can run on multiple nodes.

The rules that define the behavior of your application. You can create classes to gather rules related to a specific object in your application. For example, in a recruitment application, you can create a class that contains rules that define the flow of the recruitment process. Classes can contain other classes, hence a class that contains another class is called a parent class, while a class that is contained by another class is called a child class. A child class can reuse, or inherit, any of the rules that are defined for its parent class, which helps to build your application faster and more efficiently.

The building blocks of your user interface, sections can use design templates for their structure and contain such interactive UI elements as fields, buttons, lists, and so on. A section creates a functional chunk of a user interface, and can be reused throughout your application for improved consistency and efficient development.

For example, your application may need to display user data as a list of ID cards. You can create a section for the contents of a card, and then reuse that section so that the design of every card is consistent.

While a class contains rules which define the behavior of your application, class inheritance allows your application to reuse the existing rules for other cases or applications. Rule reuse reduces development and testing time without sacrificing application quality. Thanks to inheritance, a child class can use all of the rules that are defined for the parent class. The system supports two types of class inheritance: directed inheritance and pattern inheritance. Pattern inheritance allows you to reuse rules within a single application only, whereas directed inheritance allows you to reuse rules in other applications. For example, you design a banking application that contains two divisions: Customer Support and Business. The divisions can use pattern inheritance to share rules related to the customer data because they belong to one organization. In turn, two separate applications that require to share the customer data can only use directed inheritance.

Applications have users, though not all users perform the same tasks. Roles define how users interact with the application by, for example, determining the user interface, page permissions, and routing that are available to a user. For example, in Pega Workforce Intelligence there are several user roles, including administrator, analyst, and report user.

A user access role that is used on application servers to control access to servlets.

A program component that defines and implements an interface between an external application acting as a client, and a Pega Platform system acting as a server. An external system can send a request to a Pega Platform application and receive a response.

For example, the Pega Cloud Services SFTP service provides Pega Cloud clients with simple, secure file transfers to and from their Pega Cloud applications.

An application-specific access control element that is associated with a class and an access role. Using privilege rules in an application is optional, but they can offer improved control over access than access roles alone.

The sequential processing unit in Pega Platform that consists of one or more steps. Each step can call a Pega Platform method, transfer control to another activity, or run custom inline Java.

This is a deprecated term for what is now known as the work queue.

This is a deprecated term for what is now known as the work queue.

A set of users who receive access to application or network resources through their membership in the group. When a user is added to an access group, that user receives the permissions that are associated with the group. If a user belongs to more than one access group, that user acquires the set of access permissions that are associated with each group. You can create multiple access groups within an application to convey different levels of access based on user roles.

An element that defines a Java function and makes the function callable from activities and expressions. A function is an instance of the Rule-Utility-Function rule type.

The building blocks of your user interface, sections can use design templates for their structure and contain such interactive UI elements as fields, buttons, lists, and so on. A section creates a functional chunk of a user interface, and can be reused throughout your application for improved consistency and efficient development.

For example, your application may need to display user data as a list of ID cards. You can create a section for the contents of a card, and then reuse that section so that the design of every card is consistent.

A graphical representation that models a business process in your application by using graphical shapes and connectors to define a sequence of events. You can edit a flow in the life cycle of a case or by using the Flow form.

A template for a case in an application.

The basic building blocks of an application, rules define the behavior of an application. There are many types of rules, each defining a different type of behavior. For example, rules define the display of a form, the fields that are used in your application, and the flows that define the process of completing work.

The system can reuse rules throughout your application. For example, in an application for ordering replacements parts, you can define a user interface to capture an address, and reuse the same rule for the UI to capture both the mailing address and the billing address for the order.

You define rules in an application to create a business solution for your organization and customers. Rules provide flexibility during the development process and help you design applications more efficiently, so that they can be implemented again in future projects.

A definable structure that you can use to organize your workforce into logical groupings and reflect who reports to whom. Pega Workforce Intelligence uses the hierarchy that you define for reporting and analysis. You can label the levels in the hierarchy to match the company's business structure, such as divisions, departments, supervisors, managers, associates and so on.

A data structure that holds name-value pairs. Pages are stored in the system memory or in the database. Various types of pages are defined in the system, such as data pages that are created when the data is referenced, named and unnamed pages, parameter pages, clipboard pages, and so on. Every unit of information in an application is a pairing of a name and a value, known as a data element. For example, a data element that stores the email address of a customer has the name "email," and the value "john.smith@company.com." Pages store data elements so that the application can use it to process the case.

A reference to a clipboard page that is available to an activity, or to a new page that is created by a step. Each step in an activity could have a designated step page. The step page becomes the primary page for the duration of the step's execution.

An activity that controls the way that users interact with forms that they need to fill in to complete their tasks. The flow actions associated with a task determine the choices that are available to users as they perform the task. For example, in a damaged goods claim process, the buyer can select to have the goods either reimbursed or replaced.

An activity that controls the way that users interact with forms that they need to fill in to complete their tasks. The flow actions associated with a task determine the choices that are available to users as they perform the task. For example, in a damaged goods claim process, the buyer can select to have the goods either reimbursed or replaced.

A graphical representation that models a business process in your application by using graphical shapes and connectors to define a sequence of events. You can edit a flow in the life cycle of a case or by using the Flow form.

(Deprecated) A configuration of panels (areas) in a harness that support a composite portal. Existing panel sets continue to function. As a best practice, upgrade panel sets to screen layouts.

An entity that models data in your business processes and defines what information you need to provide to reach your business goal. For example, in a process of hiring new employees, you can create properties that correspond to the personal details of a candidate, such as a name, a surname, and an address. Then, when you review applications from different candidates, you provide values specific to each candidate. To save time and make your application more relevant to customers, you can reference properties in different elements of your application, and then populate them with data at run time. For example, you can include a property that references a customer name in an email that your application sends automatically. As a result, each time that the email message is personalized and includes an actual customer name. Properties help you collect and provide consistent data irrespectively of the method in which users interact with your application. By referencing properties, you ensure that a user receives the same information through a website, an email, or a mobile app.

A durable, potentially permanent, saved representation of a concrete class that is stored in the database. An instance corresponds to a row in the relational database, or to a record. An instance consists of properties and values, and some of these property values form a unique key to the instance.

A single line of Pega Platform syntax that provides computation of a value by using arithmetic operators, logical operators, Java operators, standard functions, and properties. On many forms, you can start the Expression Builder to provide prompting and guidance while entering an expression.

An object created in the adapter control that represents a native control in an application that you are automating. There are many types of targets and each target represents a specific type of control. For example, a GridTarget knows how to get cell values, set cell values, and so on. A ListBoxTarget provides a count of items and returns the items as a list.

Validate rules help you to ensure that users enter valid values in forms and that the system can process the information correctly. A validate rule tests input values against conditions that you define as part of the rule. If a value that a user enters does not meet the conditions, the system displays an error message when the user submits the form. For example, you can ensure that customers provide their name and address before placing an order, or that the date of birth they provide is not in the future.

A layout that organizes UI elements on the screen in a variety of ways. For example, you can use dynamic layouts in forms to determine item and label placement depending on the size of the screen that you use, such as desktop monitors or mobile displays. You can also define how dynamic layouts behave on mobile devices to improve readability by defining how much content is displayed on the screen at a time.

A layout that displays values of a Page List, Value List property, data page, or a report definition in a spreadsheet format. When a grid is bound to a data page or report definition that accepts parameters, and the parameter value uses a property reference, the grid is automatically refreshed whenever the property value changes. The grid is created dynamically and has as many rows as needed to display the requested data. The grid can be read-only.

A single line of Pega Platform syntax that provides computation of a value by using arithmetic operators, logical operators, Java operators, standard functions, and properties. On many forms, you can start the Expression Builder to provide prompting and guidance while entering an expression.

An action that does not require human involvement but can instead be done programmatically.

A text string that is stored in a Java StringBuffer object rather than in a page structure. Local variables require less memory and can be accessed with less computer overhead than parameters. Activities can access local variables.

A characteristic that defines and holds data for your application. For example, the Customer data type might be used to manage customer contact information. It might include the customer's name, email, phone number, and so on. Data types are managed using the Data Explorer.

The final phase of the Pega Express methodology that encompasses business readiness including training, go-live planning, production deployment, and release retrospectives.

Anything that impacts the objectives, cost, timeline, or resources on a project. Even changes that have no cost impact should be logged. A change may be instigated by the project team or the customer. Change requests should be recorded on the weekly Project Status Report and in a change log.

An entity that you use to cache data on demand to a clipboard page for use by one or more applications. A data page rule defines the source, scope, refresh strategy, editability, and structure of the cached data. Data pages were previously known as declare pages.

An optional qualification that is available for supported rule types and is built upon an unqualified rule known as the base rule. By using circumstances in your application, you can easily support a variety of use cases.

The event or method that starts the processing of a specified action in response to another event or method.

A task that a user completes so that the business process can advance towards the final resolution. You can add assignments to the business process to collect information or seek approvals from users with different roles or levels of expertise. For example, in an online credit card application, a customer needs to fill out the online credit card application form by providing a range of personal and financial details. When the application form is completed, the process advances to the bank employees who can process the request by either approving or rejecting the application.

The process of assigning tasks in a business process to an individual or group of individuals who are the most capable of completing those tasks.

For example, when creating an expense report, an employee creates the report, a manager approves it, and a payroll employee then sends the payment. To process employee compensation payments, you can route the task to the work queue of the payroll team, in which any member of that team can access, select, and process the work item.

If you need a specific person to work on the assignment, you can route the assignment to a work list. For example, when a human resource manager needs to approve employee time off requests, you can route the assignment to the worklist of the human resources manager.

If you need a person with a particular skill set to work on the assignment, you can route the assignment using business logic to a skilled group by defining a specific condition. For example, in an automobile quote request, a prospective customer fills in a form and selects an Electric vehicle check box. The request is then routed to the electric car insurance underwriters work queue, members of which specialize in electric cars.

A task that a user completes so that the business process can advance towards the final resolution. You can add assignments to the business process to collect information or seek approvals from users with different roles or levels of expertise. For example, in an online credit card application, a customer needs to fill out the online credit card application form by providing a range of personal and financial details. When the application form is completed, the process advances to the bank employees who can process the request by either approving or rejecting the application.

A container that organizes the content and structure of a page in the user interface. The layout of a harness is defined by a template. For example, you can base a portal harness on a template that divides the portal into three separate areas: a header, a navigation pane, and a large content pane for displaying documents.

A value that identifies one element (or member) of an aggregate data structure. These indexes are sometimes called subscripts. In addition, an index is a PegaRULES database feature that provides faster access and improved database performance. Use Declare Index rules to add and delete index objects.

An element that defines a Java function and makes the function callable from activities and expressions. A function is an instance of the Rule-Utility-Function rule type.

An optional qualification that is available for supported rule types and is built upon an unqualified rule known as the base rule. By using circumstances in your application, you can easily support a variety of use cases.

The smallest element of your business process, a step represents a single task. A step can be a user action, such as collecting information from a customer, or an automation that an application performs, for example, sending an email to a customer when a business process reaches resolution. When you visualize your work, you order steps in a sequence that communicates what actions are required to reach your business objective. You can select from a wide choice of steps to ensure that you reach your goals in the most efficient way.

A permanent, unique identifier for a class that includes certain key parts, and the creation date and time of a single instance for rules and some classes. A handle is sometimes known as an internal key. The pzInsKey property holds the handle value for an object. The pzInsKey property is undefined until you save the object.

A mechanism that secures an object or a ruleset version against changes. You can lock ruleset versions, instances of a concrete class, and the Rule-Application rule type.

An independent review in a workflow by one person of some part of another person's work (and of the system's work), before that work becomes final. Verification is common in financial workflows involving large dollar amounts or sensitive legal commitments.

A task performed by a worker, such as a customer service representative (CSR), while working in a business process. For example, a user action could be a CSR entering income details in a loan request dispute. Other user actions can include changing the stage of a business process, creating assignments, and adjusting goals and deadlines. By incorporating user actions into your business processes, you ensure that the work that you create can be manually adjusted to meet dynamically changing circumstances.

A parent case of one or more related cases. Typically, one work party, such as the customer party, is present in the cover case and in all of the covered cases that are associated with it. The covered cases are the children in a parent-child relationship. A cover can be a parent of other cover objects (and their children). Use a case type rule in the cover class to define the covered objects for the parent cover.

Actual work that is performed by application users and automations that consists of a sequence of tasks and leads to an intended business goal. An example of a case is a process of hiring a particular job candidate, where an HR worker collects necessary documents, a hiring manager conducts a job interview, and an application sends an automated email with onboarding information after the candidate is approved. To create a case, you first build a template of your business process that is a case type, and then apply the template in multiple cases, for example, to review applications from many candidates.

A Pega Platform method, distinct from a Java method. An operation that can be performed by one step of an activity ( Rule-Obj-Activity rule type), or by a Parse Structured rule ( Rule-Parse-Structured rule type).