Cache in pega instance
Cache management is a critical system administration function in Pega Platform™. To optimize run time performance, Pega Platform caches frequently accessed items, such as compiled Rules, declarative logic, data pages, and static content. When application changes do not appear as expected, or system behavior seems stale, clearing the appropriate cache is the recommended solution.
Every time a user interacts with an application (for example, when they click a button, create a Case, or advance a process), the Pega engine makes hundreds of decisions about which Rules to run, what data to fetch, and how to render the user interface. If the engine queried the database for every decision, the system would be slow and would not scale.
To prevent this behavior, each Pega node maintains high-speed, in-JVM (Java Virtual Machine) memory known as the cache. The cache stores information that the node has already processed, such as resolved Rules and frequently used data, so that the node can retrieve and reuse this information quickly. Pega Platform uses several distinct cache types, and each type has a specific purpose.
Cache types
Pega Platform™ uses different cache types, and each type affects system performance in a different way.
Rule cache
The Rule cache stores compiled Rules to accelerate Rule resolution. It is the cache that administrators most frequently clear during troubleshooting scenarios that involve stale Rule behavior.
Declarative and conclusion cache
Declarative and conclusion caches store compiled declarative Rules and their resolved conclusions. Clear these caches when declarative logic changes do not propagate correctly at run time.
Data page cache
Specific Data Pages store cached data in memory to reduce redundant data retrieval. Clear individual Data Pages when configuration data, such as repository settings, undergoes updates.
Server-side static content cache
CSS, JavaScript, and other static assets are cached to improve browser load performance. Pega Platform agents typically manage this cache, so manual clearing is rarely required.
Content Delivery Network image cache
When images are stored in the Pega repository, they are cached on a Content Delivery Network (CDN). Cache invalidation behavior differs by repository type.
The following table summarizes the cache types and their details:
| Cache type | Purpose | Contents | When to clear |
|---|---|---|---|
| Rule cache | To store resolved Rules so that the engine does not repeatedly assemble them. | Assembled activities, Flows, Data Transforms, Sections, and harnesses. | When Rule updates do not take effect or logic appears stale. |
| Declarative and conclusion cache | To store the outcomes of declarative Rules (for example, Declare Expressions) and decision logic (for example, When Rules) to avoid recalculating values. | Computed property values and true or false outcomes from evaluated logic. | When declarative logic or decision outcomes do not update after property values change. |
| Data Page cache | To maintain a temporary, in-memory store of data (for example, customer details) to reduce queries to source systems. | Data Pages cached at thread, requestor, or node scope. | When the source data is updated and the application requires the latest data. |
| Server-side static content cache | To avoid rebuilding UI structures for every screen load by caching assembled UI components. | Assembled Sections, Harnesses, UI metadata, skins, CSS, and JavaScript. | Pega Platform agents manage this cache, and manual clearing is rarely required. |
| CDN image cache | To use a CDN to deliver static images to users with low latency from a geographically close server. | Icons, logos, and other static visual elements. | The CDN automatically fetches an image from the Pega server when the image is not cached and then serves it. |
A Lead System Architect is accountable for the performance, stability, and maintainability of an application. Understanding caching is essential because cache design directly affects these attributes.
Key considerations:
- Performance and stability: Most performance bottlenecks relate to inefficient caching rather than slow databases. A poor caching strategy can lead to excessive memory consumption, frequent garbage collection, and system instability under load.
- Predictable behavior: Proper cache management ensures that applications operate consistently across environments.
- Architectural excellence: An LSA must design solutions that use caching effectively. A well-architected Pega solution uses the cache to minimize database calls and avoid recomputing logic unnecessarily.
A successful LSA must understand which operations are served from the cache, which operations require database interaction, and which operations force the engine to rebuild logic. This knowledge is fundamental to building scalable and robust Pega applications.
Check your knowledge with the following interaction: