Design patterns

Enterprise application development benefits from adopting design patterns. By applying the latest technologies and best practices, including intelligent automation and AI-driven decision-making, organizations can enhance agility, efficiency, and scalability. Design patterns accelerate development and support consistent architecture.

Pega Platform™ enables Lead System Architects (LSAs) to adopt AI features, automate processes intelligently, and deliver exceptional user experiences. Its architecture supports the adoption of design patterns for the creation of robust structural elements in applications.

As an LSA, apply design thinking techniques at the start of application design. Break down customer journeys into Microjourneys®. Accelerate this process by using the Blueprint Delivered™ methodology.

Application design patterns provide a structured approach to solving common design challenges. They streamline development, improve modularity, and enhance system resilience.

In Pega Platform™ application development, a microservices-oriented approach offers significant advantages. Implement this approach by using design patterns that optimize Pega features. These patterns help developers structure applications to manage complex business processes efficiently while remaining flexible and responsive to changing requirements.

You can implement Microjourneys® within a microservices-oriented approach by applying these design patterns:

• Divide and conquer
• Straight-through processing (STP)
• Remote Case processing

Divide-and-conquer

Divide-and-conquer is an algorithmic approach that breaks tasks into smaller, independently solvable units. Each unit is recursively divided until it is simple enough to solve directly. The solutions to these smaller units are then combined to form the overall result.

In Pega applications, the divide-and-conquer strategy is implemented by adopting Microjourneys® with the right level of granularity in an outcome-focused way. Complex business journeys are broken into smaller, manageable segments, each representing a specific business process with a defined outcome. This approach accelerates development, improves user adoption, and enables faster realization of business outcomes.

Straight-through processing

Straight-through processing is a design pattern that automates processes by removing manual intervention. It creates an end-to-end automated flow where data or transactions move from initiation to completion without human involvement. This approach increases efficiency, reduces errors, and accelerates processing times.

As an LSA, use Pega GenAI™ and agentic AI features to implement STP in application development. These features enable autonomous decision making, dynamic workflow orchestration, and proactive exception handling to achieve true end-to-end automation without manual intervention.

Remote Case processing

Remote Case processing supports managing Cases from multiple applications in a single application context, which removes the need to switch between systems. This approach improves efficiency and provides a seamless experience because Case workers complete tasks without logging in and out of different applications.

Pega Platform™ implements Remote Case processing through Remote Case Types. For more information, see Remote Case Types.

For example, a customer service representative (CSR) who manages financial operations for VIP customers typically handles loan requests, mortgage requests, and credit card operations across multiple applications. With Remote Case processing, you can create a VIP financial operations application to consolidate these cases. The CSR processes loan requests, mortgage requests, and credit card operations in a single application, which reduces time spent switching between systems and improving productivity.

When designing structural elements, focus on using technical features effectively and maintaining flexibility to implement Microjourneys as structural elements of the enterprise application. Structural elements in a Pega application can include Case Types, Data Types, Child Case Types, Child Processes, Stages, Steps, or any other components that form part of the application. The concept of Microjourneys in the context of structural elements of the application can be implemented using the following design patterns:

• Case instance first
• Data instance first
• Data instance only
• Limited availability and concurrency

Case instance first

The Case-instance-first design pattern in Pega Platform™ is similar to the object-action interface in core programming languages. In this pattern, an action is performed on an existing object. Apply the Case-instance-first design pattern in scenarios where the context of a Case instance is essential for completing specific actions or transactions.

For example, consider a purchase order (PO) process. Creating a PO is required before proceeding with subsequent actions, such as approval and billing. Both actions occur within the context of the PO Case, demonstrating the Case-instance-first approach. This pattern ensures that all actions align with the Case instance, promoting a coherent and efficient workflow.

Data instance first 

The data-instance-first design pattern demonstrates how data related to a Case persists before the Case is created. For example, when using a Web embed, you do not always need to create a Case immediately. Instead, you can persist Case data first by using the Display a page action rather than the Create a Case action in the Web embed. Case creation occurs later, after enough data is collected or a decision is made to proceed.

For example, not every job application triggers a recruitment process. Applicant information can be stored as a data instance before creating a Case.

Data instance only 

The data-instance-only design pattern supports simple, non-process-oriented data capture and persistence in the required format and location. Other objects can reference and process the persisted data.

For example, consider a functional requirement to capture and display the office locations of a global mobile sales and service company. Office administrators can add, delete, modify, or update office locations whenever the company changes its service locations. Office location is an important attribute for service requests and contributes to service fee and tax calculations. Implement this scenario by applying the data-instance-only design pattern.

Limited availability and concurrency 

The limited-availability-and-concurrency design pattern is a variant of the object-action approach pattern. Use the limited-availability-and-concurrency design pattern to address race-condition problems when multiple requests compete for limited resources. This pattern ensures efficient resource use without overbooking or overuse.

The simplest approach is for a requester to acquire a lock on the resource, update the resource, and then release the lock. The next requester in the queue acquires the lock. If resources remain available, the next requester uses them; otherwise, the process ends.

In Pega implementations, apply locking to Case Types or Data Types. If you need Case Management features (for example, routing and Service-Level Agreements), implement limited availability and concurrency by using Case Types. Otherwise, the simplest approach is to use Data Types by acquiring a lock on the concrete Data Type to avoid simultaneous updates.

Check your knowledge with the following interaction: