PEGACPLSA23V1 Application Design

Application Design Detailed Explanation

Application Design in Pega focuses on creating solutions that meet business needs, provide scalable automation, and ensure efficient workflows. A well-designed application aligns technical implementation with business objectives and improves user experience.

3.1 Microjourney Design

What is a Microjourney?

A Microjourney is a small, focused business process designed to deliver a specific business outcome.

• Instead of automating a large, complex process all at once, you break it into smaller, manageable steps.
• Each Microjourney focuses on one specific user goal or result.

Why Use Microjourneys?

1. Focus on Outcomes: Each Microjourney has a clear, measurable result.
2. Incremental Delivery: You can build and deploy one Microjourney at a time, enabling faster results.
3. Easier to Maintain: Smaller pieces of functionality are easier to test, modify, and reuse.
4. User-Centric: Microjourneys align with customer needs and deliver better user experiences.

Microjourney Structure

Microjourneys are designed using three key components:

1. Stages
2. Steps
3. Processes

1. Stages

• A Stage represents a major milestone in a Microjourney.
• It organizes the overall flow into clear phases.
• Stages help both developers and business users visualize the progression of a business process.

Characteristics of Stages:

1. Sequential: Stages typically occur in sequence, but they can also be skipped or returned to if necessary.
2. High-Level: Stages provide an overview of what happens without going into technical details.
3. Outcome-Focused: Each stage delivers a significant part of the overall business result.

Example: Loan Application Process
Stages in a loan approval process could include:

Stage	Purpose
Initiate	Capture basic customer information.
Review	Verify submitted documents.
Approval	Approve or reject the application.
Closure	Notify the customer and finalize.

2. Steps

• A Step is an action or task that occurs within a stage.
• Steps provide detailed activities that move the case forward.
• Steps can include:
  • Assignments: Tasks for users to complete (e.g., “Verify documents”).
  • Processes: Automated workflows (e.g., sending notifications).
  • Subprocesses: Smaller workflows within a step.

Example: Steps in the “Review” Stage

In the Review stage of a loan application, the steps might include:

1. Collect Documents: Gather ID proof, income statements, etc.
2. Verify Documents: Ensure all required documents are valid.
3. Notify Status: Send an email updating the customer on progress.

3. Processes

• A Process is an automated workflow that defines how tasks are performed in a step.
• Processes can include:
  • Sequential Flows: Tasks happen in a defined order.
  • Parallel Flows: Tasks happen simultaneously.
  • Decision Logic: Rules that control the flow of the process (e.g., “If income > $50,000, approve loan”).

Example: Process for “Verify Documents”

The Verify Documents step can include the following automated process:

1. Check if the uploaded documents meet the required format (e.g., PDF, less than 5 MB).
2. Validate information in the documents against the customer’s submitted form.
3. If successful, mark the document as Verified.
4. If unsuccessful, send an email to the customer requesting corrections.

Best Practices for Microjourney Design

1. Keep Stages Simple: Limit each stage to 5-7 steps to keep processes clear and focused.
2. Modular Design: Break large tasks into smaller, reusable processes.
3. Use Meaningful Names: Name stages and steps based on their purpose (e.g., “Document Review” instead of “Stage 2”).
4. Focus on Business Outcomes: Ensure each Microjourney delivers a specific result (e.g., “Application Approved” or “Customer Onboarded”).
5. Avoid Overloading Stages: If a stage has too many steps, consider breaking it into two stages.

Real-World Example: Loan Application Microjourney

To summarize, let’s map out a Loan Application Microjourney:

Stage	Steps	Processes
Initiate	Collect Customer Information	Validate data and store in the system.
Review	Collect Documents → Verify Documents	Automated validation → Send status email.
Approval	Manager Approval → System Decision Check	Approve/reject loan → Notify outcome.
Closure	Notify Customer → Archive Loan Application	Send approval letter → Close the case.

Benefits of Well-Designed Microjourneys

1. Faster Development: Build, test, and deploy small components incrementally.
2. Clear Visibility: Business stakeholders can easily understand and approve processes.
3. Improved User Experience: Focus on delivering one goal at a time to reduce complexity.
4. Scalability: Add more Microjourneys as business needs evolve.

Summary of Microjourney Design

• Microjourneys are small, focused processes designed to deliver specific business outcomes.
• Each Microjourney consists of:
  • Stages: Major milestones.
  • Steps: Actions within stages.
  • Processes: Automated workflows.
• Following best practices ensures Microjourneys remain modular, clear, and efficient.

3.2 Case Design

In Pega, a case represents a business process or transaction that needs to be managed and resolved. Case Design is about structuring these cases efficiently so that they align with business objectives and deliver the desired outcomes.

Core Components of Case Design

1. Case Types
2. Parent and Child Cases
3. Dynamic Case Management
4. SLA Configuration
5. Routing and Assignments
6. Escalations

3.2.1 Case Types

What is a Case Type?

A Case Type in Pega defines the life cycle of a business process. It organizes tasks, decisions, and data into a structured process to achieve a specific outcome.

Case Type Structure

A case type includes:

1. Stages: High-level milestones or phases in the case life cycle.
2. Steps: Actions performed within each stage (e.g., forms to fill out, decisions to make).
3. Processes: Automation or logic used to execute steps.

Examples of Case Types

1. Loan Application:

   • Purpose: Process a loan request from initiation to approval.
   • Stages: Initiation → Review → Approval → Closure.

2. Customer Onboarding:

   • Purpose: Register a new customer in a bank.
   • Stages: Collect Information → Document Verification → Account Creation.

3. Employee Hiring:

   • Purpose: Hire new employees in an organization.
   • Stages: Application Submission → Interview → Offer → Onboarding.

Benefits of Case Types

1. Clear Structure: Organizes processes into logical stages and steps.
2. Adaptable: Easy to modify and extend as business requirements evolve.
3. Reusable: Standardized case types can be reused for similar business processes.

3.2.2 Parent and Child Cases

What are Parent and Child Cases?

• Parent Case: Represents the main process or a high-level business objective.
• Child Case: Breaks the parent case into smaller, manageable parts that can be handled independently.

Why Use Parent and Child Cases?

1. Manage Complexity: Large processes can be broken down into smaller, modular components.
2. Parallel Processing: Child cases can be worked on simultaneously, improving efficiency.
3. Reusability: Child cases can be reused across different parent cases.

Example of Parent and Child Cases

Scenario: Processing an Insurance Claim.

Parent Case	Child Cases
Insurance Claim	1. Document Collection
	2. Damage Assessment
	3. Payment Processing

1. Document Collection: Collect required documents from the customer.
2. Damage Assessment: Verify the claim by assessing the reported damage.
3. Payment Processing: Approve and process the payment.

• These child cases can run in parallel to reduce processing time.
• Once all child cases are resolved, the Parent Case can move to completion.

Benefits of Parent and Child Cases

1. Simplifies Management: Focus on smaller, manageable parts of the process.
2. Parallel Execution: Work on multiple child cases simultaneously to save time.
3. Error Isolation: Errors in one child case do not impact others.
4. Reusability: Child cases can be reused in other processes.

3.2.3 Dynamic Case Management

What is Dynamic Case Management?

Dynamic Case Management allows you to adjust the workflow of a case in response to real-time business changes or user input.

How Does It Work?

1. Case Routing: Dynamically route cases based on conditions (e.g., assign urgent tasks to senior employees).
2. Optional Actions: Allow users to perform tasks outside the standard flow when needed.
3. Ad-Hoc Steps: Add steps or tasks to the case on the fly.

Example of Dynamic Case Management

Scenario: Handling a Customer Complaint.

• Standard Flow:
  1. Receive Complaint → 2. Investigate → 3. Resolve → 4. Notify Customer.
• Dynamic Adjustment:
  • If the complaint escalates, add an Ad-Hoc Step: “Review by Senior Manager.”
  • Allow users to perform an Optional Action: “Offer a Discount” to resolve the issue quickly.

Benefits of Dynamic Case Management

1. Flexibility: Adjust workflows in real time to handle unexpected events.
2. Improved Responsiveness: Quickly resolve complex or unpredictable cases.
3. Enhanced User Control: Allow caseworkers to add tasks or actions when required.

3.2.4 SLA Configuration

What is an SLA?

An SLA (Service Level Agreement) defines deadlines for task completion and specifies actions to take when those deadlines are missed.

Key SLA Components

1. Goal: The expected time to complete a task.
2. Deadline: The maximum time allowed to complete a task.
3. Passed Deadline: Actions to perform if the deadline is missed.

Example of SLA Configuration

Scenario: Loan Application Review

• Task: Verify Loan Documents.
• Goal: Complete within 4 hours.
• Deadline: Complete within 8 hours.
• Passed Deadline Action:
  • Notify the manager via email.
  • Reassign the task to another user.

Benefits of SLAs

1. Timely Completion: Ensures tasks are completed on time.
2. Escalation Management: Automates escalation when deadlines are missed.
3. Improved Accountability: Tracks task performance and identifies bottlenecks.

3.2.5 Routing and Assignments

What is Routing?

Routing determines who will perform a task in the case process.

Routing Methods

1. Work Queue (Workbasket): Assign tasks to a shared queue for a group of users.
2. Specific User: Route tasks to a specific individual.
3. Skill-Based Routing: Route tasks to users with specific skills.
4. Dynamic Routing: Use business rules to assign tasks based on conditions.

Example of Routing

Scenario: Document Verification in Loan Application

• Route tasks as follows:
  • Standard Loan: Assign to a junior loan officer.
  • High-Value Loan: Assign to a senior loan officer.

Dynamic Routing: Use business logic to decide routing dynamically based on loan amount.

3.2.6 Escalations

What is Escalation?

Escalation ensures tasks are addressed when SLAs are missed. It can notify stakeholders, reassign tasks, or change priorities.

Example of Escalation

Scenario: Task: Approve Loan Application

• SLA Missed: Approval not completed within 8 hours.
• Escalation Actions:
  1. Notify the manager via email.
  2. Reassign the task to the manager.

Summary of Case Design

1. Case Types: Define the structure and life cycle of a business process.
2. Parent and Child Cases: Break processes into smaller, manageable components.
3. Dynamic Case Management: Adjust workflows dynamically for flexibility.
4. SLA Configuration: Define goals, deadlines, and escalation actions.
5. Routing and Assignments: Assign tasks to users or queues based on rules.
6. Escalations: Automate actions when SLAs are missed.

3.3 Pega Express Methodology

Pega Express is Pega's design and delivery methodology used to implement applications efficiently. It is built on agile principles and focuses on delivering incremental value to businesses by identifying and building Microjourneys.

Key Characteristics of Pega Express

1. Outcome-Driven: Focuses on delivering business outcomes through Microjourneys.
2. Agile and Iterative: Work is broken into smaller, manageable phases with continuous feedback.
3. Minimum Viable Product (MVP): Delivers a functional version of the application quickly.
4. Collaboration: Involves business stakeholders, developers, and end users throughout the process.

Four Stages of Pega Express Methodology

Pega Express consists of four stages:

1. Discover
2. Prepare
3. Build
4. Adopt

3.3.1 Discover

Purpose of the Discover Stage

The Discover stage is where you identify business objectives, define the scope, and understand the requirements. This phase focuses on finding the Microjourneys that will deliver the most value.

Key Activities in the Discover Stage

1. Identify Business Outcomes:

   • Work with stakeholders to define the specific outcomes the application must achieve.
   • Example: For a loan application system, the outcome could be “Approve loans within 24 hours.”

2. Define Microjourneys:

   • Break down the overall process into smaller, focused Microjourneys.
   • Example: For a loan system:
     • Microjourney 1: Application Submission
     • Microjourney 2: Document Verification
     • Microjourney 3: Approval and Disbursement

3. Map Case Life Cycles:

   • Outline the stages and steps for each Microjourney.
   • Example:
     • Stage 1: Collect Information
     • Stage 2: Review Documents
     • Stage 3: Approve Loan

4. Understand Personas:

   • Identify user roles (personas) that will interact with the application.
   • Example:
     • Loan Officer: Reviews loan applications.
     • Manager: Approves high-value loans.
     • Customer: Submits loan requests.

5. Capture Requirements:

   • Document business requirements and prioritize them based on importance.

Outcome of the Discover Stage

• A clear list of Microjourneys to focus on.
• A high-level case design with stages, steps, and expected outcomes.
• Defined personas and their roles in the process.
• Prioritized business requirements.

3.3.2 Prepare

Purpose of the Prepare Stage

The Prepare stage focuses on planning the implementation. This is where you finalize the Minimum Viable Product (MVP), design the initial case structures, and align on priorities.

Key Activities in the Prepare Stage

1. Define the MVP (Minimum Viable Product):

   • The MVP is the smallest, functional version of the application that meets key business goals.
   • Example: For a loan system, the MVP could include:
     • Customer application submission.
     • Document collection and verification.

2. Design Initial Case Structure:

   • Build a skeleton of the case type, including:
     • Stages: Major milestones.
     • Steps: Actions within each stage.
   • Example:
     • Stage 1: Application Submission
     • Stage 2: Verification
     • Stage 3: Approval

3. Prioritize Features:

   • Work with stakeholders to prioritize features for the MVP and future phases.
   • Focus on delivering high-value features first.

4. Plan the Build:

   • Create a plan for development and testing.
   • Identify key team members and their responsibilities.

5. Set Up the Development Environment:

   • Prepare Pega environments (Development, QA, and Production) for implementation.

Outcome of the Prepare Stage

• Defined MVP with clear features and priorities.
• Initial case life cycle design.
• Development plan and team alignment.
• Prepared environments for the Build phase.

3.3.3 Build

Purpose of the Build Stage

The Build stage is where the application is developed and tested. It involves creating workflows, automations, user interfaces, and data integrations to meet the requirements.

Key Activities in the Build Stage

1. Develop the Case Types:

   • Create case types with stages, steps, and processes.
   • Example: Build the loan application case type with stages for Submission, Review, and Approval.

2. Configure UI:

   • Design forms, screens, and dashboards using Pega’s low-code tools.
   • Use Cosmos Design System for modern, responsive UI components.

3. Integrate Data:

   • Use Data Pages and Connectors to fetch or send data to external systems.
   • Example: Integrate with a Credit Bureau API to fetch customer credit scores.

4. Automate Processes:

   • Build automation for tasks like email notifications, validations, and decision logic.
   • Use Flows and Decision Rules to automate case progression.

5. Perform Testing:

   • Test the application incrementally to ensure it meets requirements.
   • Perform unit testing, integration testing, and user acceptance testing (UAT).

Outcome of the Build Stage

• A functional application that meets the MVP requirements.
• Tested case types, workflows, and integrations.
• A user-friendly UI with the necessary automation.

3.3.4 Adopt

Purpose of the Adopt Stage

The Adopt stage focuses on rolling out the application to end users and ensuring successful adoption. This phase also involves gathering feedback for future improvements.

Key Activities in the Adopt Stage

1. Deploy the Application:

   • Move the application to the Production Environment.

2. Train End Users:

   • Provide training sessions, documentation, and guides for end users.
   • Example: Train loan officers to use the loan approval system.

3. Monitor Adoption:

   • Use Pega Predictive Diagnostic Cloud (PDC) or performance dashboards to monitor how users interact with the application.

4. Collect Feedback:

   • Gather feedback from end users to identify areas for improvement.
   • Use this feedback to plan future updates.

5. Plan for Continuous Improvement:

   • Add new features or enhancements based on user needs.

Outcome of the Adopt Stage

• A successfully deployed application in production.
• Trained and satisfied end users.
• Feedback collected for future iterations.
• Continuous improvement plan for ongoing development.

Summary of Pega Express Methodology

1. Discover: Identify business outcomes, Microjourneys, and case structures.
2. Prepare: Define the MVP, prioritize features, and plan the implementation.
3. Build: Develop, test, and configure the application incrementally.
4. Adopt: Deploy the application, train users, and monitor adoption.

3.4 Application Modularity

Application Modularity in Pega refers to designing applications in a way that components, rules, and logic are organized into reusable and maintainable units. Modular design reduces duplication, accelerates development, and ensures consistent behavior across applications.

Why Application Modularity is Important

1. Reusability: Components can be reused across applications, saving time and effort.
2. Scalability: Modular applications are easier to extend as business requirements evolve.
3. Maintainability: Changes made to reusable components are automatically applied wherever the component is used.
4. Reduced Redundancy: Avoid duplication of logic, rules, and processes.
5. Improved Collaboration: Teams can work independently on different modules without conflicts.

Key Concepts of Application Modularity

1. Application Reuse
2. Rule Specialization
3. Examples of Modular Components

3.4.1 Application Reuse

What is Application Reuse?

Application reuse involves designing applications so that parts of the application (e.g., rules, workflows, components) can be reused in other applications or projects.

How to Enable Application Reuse in Pega

1. Break Applications into Modules:

   • Divide applications into reusable components, such as:
     • Validation rules
     • Case templates
     • User interface sections
   • Store these components in specific RuleSets to enable sharing.

2. Leverage Rule Inheritance:

   • Use Pega’s Enterprise Class Structure (ECS) to design layers that support reuse.
   • Layers include:
     • Organization Layer: Shared across the entire enterprise.
     • Division Layer: Shared within a specific business unit.
     • Framework Layer: Industry-specific reusable assets.
     • Implementation Layer: Custom rules for a specific application.

3. Built-on Applications:

   • Build new applications on top of existing ones, inheriting rules and components.
   • Example: A Customer Management Framework application can serve as a base for multiple solutions, such as loan processing and customer service.

4. Delegated Rules:

   • Allow business users to update specific rules (e.g., decision tables) without developer involvement.

Example of Application Reuse

Scenario: A bank builds a Customer Management Framework.

• Components in the Framework:

  • Case Types: Manage customer profiles, account creation.
  • UI Templates: Standard forms for customer information.
  • Integration Rules: Connectors to CRM systems.

• Reuse:

  • The Customer Management Framework is reused as a foundation for:
    1. Loan Processing Application
    2. Credit Card Application
    3. Customer Support Portal

This modular approach ensures consistency and accelerates development.

3.4.2 Rule Specialization

What is Rule Specialization?

Rule specialization allows you to create variations of rules based on specific conditions, such as user roles, regions, or product types, without duplicating the original rule.

Types of Rule Specialization

1. Circumstancing:

   • Create conditional variations of a rule based on specific property values.
   • Example: Apply different discount rules based on customer region or membership level.

   Example Use Case:

   • Base Rule: Apply a 10% discount.
   • Circumstanced Rule: If Region = Europe, apply a 15% discount.

2. Template Overrides:

   • Use specialized templates to customize forms or layouts for different use cases.
   • Example: Override a “Customer Form” for premium customers to include additional fields.

3. Inheritance:

   • Rules in child classes inherit behavior from parent classes but can be overridden when needed.
   • Example: A “Validate Loan Application” rule can have specialized logic for different loan types (e.g., Home Loan, Auto Loan).

Benefits of Rule Specialization

1. Flexibility: Customize behavior without changing the base rule.
2. Maintainability: Updates to the base rule do not affect specialized versions.
3. Efficiency: Avoid duplicating rules for minor variations.

Example of Circumstancing

Scenario: Discount Calculation Rule

1. Base Rule: Apply a 10% discount to all customers.
2. Specialized Rule (Circumstanced):
   • If Region = North America, apply a 12% discount.
   • If Region = Europe, apply a 15% discount.

With circumstancing, you create targeted behavior without duplicating the entire rule.

3.4.3 Examples of Modular Components

Here are some examples of components that can be modularized for reuse:

1. Validation Rules:

   • Rules to validate user inputs (e.g., email format, numeric values).
   • Example: “Check Email Validity” can be reused across multiple forms.

2. Case Templates:

   • Pre-built templates for case types and life cycles.
   • Example: A “Customer Onboarding” case template can be reused for loan applications and account creation.

3. User Interface Sections:

   • Reusable UI components for forms and layouts.
   • Example: A “Customer Address Section” can be reused in billing, shipping, and registration forms.

4. Decision Tables and Trees:

   • Modular rules to automate decision-making logic.
   • Example: A “Loan Eligibility Decision Table” can be reused across personal loan and auto loan applications.

5. Data Pages:

   • Centralized data sources that fetch and store data from external systems.
   • Example: A Data Page to fetch customer details can be reused in multiple workflows.

Best Practices for Application Modularity

1. Identify Reusable Components Early: During design, identify rules, processes, and UI components that can be reused.
2. Leverage Inheritance: Use class inheritance to avoid duplicating rules and templates.
3. Use Circumstancing for Variations: Specialize rules for different conditions instead of creating duplicates.
4. Organize with RuleSets: Store reusable components in dedicated RuleSets to enable sharing across applications.
5. Test Reusable Components: Ensure modular components are well-tested, as changes will affect all applications that use them.

Summary of Application Modularity

1. Application Reuse:

   • Divide applications into reusable modules (e.g., templates, components, and workflows).
   • Use RuleSets and built-on applications to enable sharing.

2. Rule Specialization:

   • Use circumstancing and inheritance to customize rules based on conditions without duplicating logic.

3. Examples of Modular Components:

   • Validation rules, case templates, UI sections, decision tables, and Data Pages.

4. Best Practices:

   • Promote reusability, avoid duplication, and ensure modular components are well-organized and tested.

3.5 User Interface Design

User Interface (UI) Design in Pega focuses on creating intuitive, interactive, and visually appealing forms, screens, and navigation structures. A well-designed UI improves user experience (UX) and makes applications efficient and easy to use.

Key Concepts of UI Design

1. Designing User Forms
2. Navigation
3. Forms and Validation
4. Accessibility

3.5.1 Designing User Forms

What is a User Form?

A form is a UI component where users interact with the application to input, view, or update information. Pega allows you to design forms using low-code tools, such as Sections and Dynamic Layouts.

Core UI Elements in User Forms

1. Sections:

   • A Section is a container for UI components, such as fields, buttons, and layouts.
   • Sections allow you to group related fields together and reuse them across the application.
   • Example: A “Customer Details Section” with fields for Name, Email, and Address.

2. Dynamic Layouts:

   • Dynamic Layouts automatically adjust the positioning of UI elements based on the screen size.
   • Types of Dynamic Layouts:
     • Inline Grid Double: Two columns side-by-side.
     • Stacked Layout: Fields arranged vertically.
     • Inline Flex: Flexible layouts for responsive design.

3. Field Types:

   • Use appropriate field types to capture user input:
     • Text Input: For single-line text (e.g., Name).
     • Dropdown: For predefined values (e.g., Loan Type: Personal, Home, Auto).
     • Radio Buttons: For single selections.
     • Checkboxes: For multiple selections.
     • Date Picker: For selecting dates.

4. Buttons and Actions:

   • Add buttons like Submit, Cancel, and Save to trigger actions in the workflow.

Steps to Create a User Form

1. Open App Studio or Dev Studio.
2. Create a Section Rule for the form.
3. Add a Dynamic Layout to organize fields.
4. Add fields (e.g., Text, Dropdown, Date Picker) to capture input.
5. Include buttons (e.g., Submit) to progress the workflow.
6. Test the form for responsiveness and usability.

Example of a Loan Application Form

Purpose: Capture customer details for a loan application.

Field	Field Type
Applicant Name	Text Input
Loan Amount	Numeric Input
Loan Type	Dropdown (Home, Auto, Personal)
Email Address	Text Input
Application Date	Date Picker
Terms & Conditions	Checkbox
Submit Button	Button

• Use a Two-Column Layout to organize the form neatly.
• Add a Submit Button to trigger the “Loan Application Submission” process.

Best Practices for Designing User Forms

1. Keep it Simple: Avoid clutter by including only relevant fields.
2. Group Related Fields: Use sections to group similar fields together.
3. Use Appropriate Field Types: Choose fields like dropdowns, checkboxes, or date pickers for better usability.
4. Make Forms Responsive: Use Dynamic Layouts to ensure the form works well on all devices (desktop, tablet, mobile).
5. Test for Errors: Include real-time validation to ensure users input correct data.

3.5.2 Navigation

What is Navigation?

Navigation refers to how users move through the application. Well-structured navigation helps users find the information or tasks they need quickly and easily.

Core Navigation Features in Pega

1. Navigation Menus:

   • Provide a top or side menu to allow users to navigate between pages or tasks.
   • Example: A bank portal with menus like “Dashboard,” “Loan Applications,” and “Customer Support.”

2. Tabs:

   • Use tabs to organize related sections within a single screen.
   • Example: A user profile screen with tabs for “Personal Info,” “Settings,” and “History.”

3. Breadcrumbs:

   • Display the path of navigation so users know where they are in the application.
   • Example: Home → Loan Application → Submit Documents.

4. Dynamic Links:

   • Allow users to quickly jump to specific tasks or screens.

Example of Navigation

Scenario: Loan Application Portal Navigation

• Top Menu:
  • Dashboard
  • My Applications
  • Notifications
• Breadcrumb:
  • Home → My Applications → Review Loan Application
• Tabs in “My Applications”:
  • Active Applications
  • Completed Applications
  • Drafts

Best Practices for Navigation

1. Keep it Consistent: Use a uniform navigation structure across the application.
2. Use Breadcrumbs: Help users track their navigation path.
3. Prioritize Accessibility: Ensure navigation works with keyboard shortcuts.
4. Minimize Clicks: Allow users to access tasks in as few clicks as possible.

3.5.3 Forms and Validation

What is Validation?

Validation ensures that users provide correct and complete input in forms. It improves data quality and prevents errors.

Types of Validation in Pega

1. Required Fields:

   • Mark fields as mandatory so users cannot submit incomplete forms.
   • Example: “Email Address” must be filled before submission.

2. Input Formats:

   • Validate formats for fields like email, phone numbers, or dates.
   • Example: Ensure the “Email Address” contains an @ symbol.

3. Real-Time Validation:

   • Validate inputs as the user types.
   • Example: Display an error message if the entered phone number is too short.

4. Custom Validation Rules:

   • Add validation logic using Edit Validate Rules.
   • Example: Validate that the loan amount does not exceed a specified limit.

Example of Field Validation

Field: Loan Amount

• Validation: Must be a positive numeric value less than $1,000,000.
• Error Message: “Loan Amount must be between $1 and $1,000,000.”

3.5.4 Accessibility

What is Accessibility?

Accessibility ensures that applications are usable by people with disabilities, following the Web Content Accessibility Guidelines (WCAG).

Key Accessibility Features

1. Keyboard Navigation:

   • Users can navigate forms and menus using the keyboard (e.g., Tab key).

2. Screen Reader Support:

   • Use ARIA labels to provide descriptions for screen readers.

3. Color Contrast:

   • Ensure sufficient contrast between text and background for visibility.

4. Field Labels:

   • Provide descriptive labels for form fields.

Example of Accessibility

Scenario: Customer Registration Form

• Field Label: “Enter your full name.”
• Screen Reader Support: Use ARIA tags to describe the field to visually impaired users.
• Keyboard Navigation: Use the Tab key to move between fields.

Summary of User Interface Design

1. Designing User Forms: Use sections, dynamic layouts, and appropriate fields to capture user input.
2. Navigation: Implement menus, tabs, and breadcrumbs for smooth navigation.
3. Forms and Validation: Ensure data quality using required fields, input formats, and real-time validation.
4. Accessibility: Follow WCAG guidelines to make applications accessible to all users.

3.6 Process Design

Process Design in Pega defines how tasks are automated, organized, and executed to achieve a specific business outcome. It involves creating workflows, configuring decision rules, and allowing users to perform optional tasks as needed.

Key Concepts in Process Design

1. Flows
2. Decision Rules
3. Optional Actions

3.6.1 Flows

What is a Flow?

A Flow in Pega defines the process steps and transitions in a case life cycle. It represents the path a case follows, including tasks, decisions, and automated actions.

Flows can be sequential (tasks occur in order) or parallel (tasks occur simultaneously).

Types of Flows in Pega

1. Starter Flow

   • The entry point of a case or process.
   • Example: Submitting a loan application triggers the starter flow.

2. Subflow

   • A smaller flow that is called within a larger flow to perform specific tasks.
   • Example: A “Document Verification Flow” runs within the loan review process.

3. Parallel Flow

   • Tasks in a flow can occur simultaneously, allowing faster processing.
   • Example: “Background Check” and “Document Review” can happen at the same time.

4. Screen Flow

   • A flow that displays multiple screens in sequence to collect user input.
   • Example: A multi-step form for submitting a loan application.

Flow Components

1. Assignment Shapes: Tasks for users to complete (e.g., “Verify Documents”).
2. Decision Shapes: Conditional logic to decide the next step (e.g., “Is Loan Amount > $50,000?”).
3. Utility Shapes: Automated actions like sending emails, updating records, or calling APIs.
4. Subprocess Shapes: Call another flow within the current flow.
5. End Shapes: Mark the completion of a flow.

Example: Loan Approval Flow

Here is a simple example of a loan approval flow:

1. Start: Customer submits the loan application.
2. Assignment: Loan officer reviews the application.
3. Decision: Check loan amount:
   • If Loan Amount ≤ $50,000 → Approve automatically.
   • If Loan Amount > $50,000 → Route to Manager for approval.
4. Subprocess: Perform “Document Verification.”
5. Utility: Send an email to notify the customer about the loan status.
6. End: Close the loan approval process.

Best Practices for Flows

1. Keep Flows Simple: Avoid creating complex, tangled flows. Use subflows to organize tasks.
2. Use Parallel Processing: Enable parallel tasks to improve efficiency.
3. Automate Where Possible: Use Utility shapes for automated tasks like notifications or data updates.
4. Error Handling: Include error-handling steps to manage unexpected issues in the flow.
5. Use Decision Shapes for Logic: Place business rules in decision shapes for better maintainability.

3.6.2 Decision Rules

What are Decision Rules?

Decision Rules automate business logic to determine outcomes based on defined conditions. They eliminate the need for manual decision-making in processes.

Types of Decision Rules in Pega

1. Decision Tables

   • A tabular format to define multiple conditions and outcomes.
   • Example: Determine interest rates based on credit score and loan type.

   Credit Score	Loan Type	Interest Rate
   > 750	Home Loan	5%
   > 750	Personal Loan	7%
   ≤ 750	Any Loan	10%

2. Decision Trees

   • A hierarchical structure to evaluate conditions sequentially.

   • Example: Approve or reject a loan application based on conditions.

   • Conditions:

     • If Loan Amount > $100,000 → Route to Manager.
     • If Credit Score < 650 → Reject Application.

3. Map Value Rules

   • Use a matrix-style lookup to map values based on input parameters.
   • Example: Map delivery charges based on weight and destination zone.

4. When Rules

   • Simple rules that evaluate a single condition.
   • Example: “When customer is VIP, apply a 10% discount.”

Example of Decision Rules

Scenario: Approve or Reject Loan Applications.

1. Decision Table:

   • If Credit Score > 700 and Income > $50,000 → Approve.
   • If Credit Score ≤ 700 → Send to Manager for approval.

2. Decision Tree:

   • If Loan Amount > $100,000 → Route to Senior Manager.
   • Else → Approve Loan.

3. When Rule:

   • If LoanType = “Home Loan” AND CreditScore > 750, apply a lower interest rate.

Benefits of Decision Rules

1. Automation: Reduces manual decision-making by applying business logic automatically.
2. Maintainability: Rules are easy to update and maintain without modifying the process flow.
3. Reusability: Decision rules can be reused across different flows and processes.

3.6.3 Optional Actions

What are Optional Actions?

Optional Actions allow users to perform tasks outside the standard process flow. These actions provide flexibility to handle exceptions or additional tasks as needed.

Examples of Optional Actions

1. Update Case Details: Allow users to edit case information outside the main flow.
2. Send Notifications: Let users send an email or message manually during the case.
3. Add Supporting Documents: Provide an option to upload extra files.
4. Cancel Case: Allow users to terminate the case if necessary.

Benefits of Optional Actions

1. Flexibility: Enables users to handle exceptions or unplanned tasks.
2. Improved User Control: Users can perform additional actions as needed without modifying the main flow.
3. Better User Experience: Optional actions help resolve issues or adjust the case quickly.

Example of Optional Action

Scenario: Loan Application Process

• Standard Flow: Submit → Verify → Approve → Notify.
• Optional Action: During “Verification,” the user can:
  • Request Additional Documents: Ask the customer to upload missing files.
  • Cancel Application: Terminate the application if incorrect data is found.

Summary of Process Design

1. Flows: Define the sequence of tasks and automate workflows using shapes like Assignments, Decisions, and Utilities.
2. Decision Rules: Use Decision Tables, Trees, and When Rules to automate business logic.
3. Optional Actions: Provide flexibility to users by allowing tasks outside the main flow.

Application Design Recap

We have now covered all key topics in Application Design:

1. Microjourney Design: Small, outcome-focused processes.
2. Case Design: Structuring case types, parent-child cases, SLAs, and routing.
3. Pega Express Methodology: Agile, value-driven development.
4. Application Modularity: Promoting reuse and specialization.
5. User Interface Design: Designing responsive, accessible, and validated UI.
6. Process Design: Automating workflows, decision-making, and enabling optional actions.

Application Design (Additional Content)

1. Visualizing Microjourneys: Case Life Cycle Model

Pega’s Microjourney approach focuses on delivering end-to-end business outcomes. To help learners understand how Microjourneys are implemented visually in Pega, include a Case Life Cycle Model diagram as shown in App Studio's Case Designer.

Breakdown of Case Visualization Components

• Stages (Blue rectangles):

  • Represent major milestones or phases in a case (e.g., “Intake”, “Approval”, “Resolution”).

  • Always sequential, high-level flow grouping.

• Steps (White rectangles within stages):

  • Represent individual actions or tasks (e.g., “Collect Customer Info”, “Validate Identity”).

  • Can be user assignments, automated steps, or subflows.

• Processes (Icon indicating flow):

  • Define how steps are carried out using flow logic (e.g., conditions, parallel paths).

  • Clicking into a step shows the underlying flow rule.

Why This Matters for Exams and Projects:

Understanding this visual model helps in:

• Designing intuitive, maintainable Microjourneys.

• Answering scenario-based questions in LSA exams.

• Communicating design logic with business stakeholders.

2. Case Reopening & Exception Handling

Case Reopening

Include a dedicated section explaining how and when to reopen a case, such as:

• Via a post-resolution action.

• Using the Reopen Case smart shape in a flow.

• Automating reopening through service-level violations or business rules.

Example: A customer support case is marked “Resolved-Completed” but reopens automatically if negative feedback is received within 48 hours.

Exception Handling

Explain strategies for error recovery:

• Alternate Stage:

  • Define a fallback stage (e.g., “Manual Review”) when a primary stage fails.

• Error Handling Flow:

  • Catch exceptions in flow execution (e.g., failed integration call).

  • Use Error Handler shapes to route to exception handling subflows.

Why Include:

• Common in real-world implementations.

• Regularly appears in LSA and architect-level interviews as troubleshooting and design validation questions.

3. Rule Resolution Mechanism

Add a new subsection under Application Modularity to demystify the Rule Resolution Process, which governs which rule version is ultimately executed.

Core Rule Resolution Factors:

1. Class Hierarchy: Inheritance from most specific to general class.

2. RuleSet and Version: Highest version in scope is chosen.

3. Circumstancing: Based on property values or dates.

4. Availability and Status: Availability (Yes, Blocked, Withdrawn) affects visibility.

Example Scenario:

Given two versions of a data transform:

• One in Data-LoanApplication, version 01-01-01.

• One circumstanced for .LoanType = "Personal".

If a case has .LoanType = "Personal", the circumstanced version is selected.

Why Include:

• Critical for designing modular, scalable applications.

• Directly impacts rule overrides, reuse, and maintainability.

• Frequently tested in scenario-based questions.

4. Pega DX API – Extending with Headless Frontends

Introduce a short section under “Extending Applications” or “User Interface Design”:

What is the DX API:

• A set of RESTful APIs that allow external frontend applications to interact with Pega cases and forms.

• Supports headless architecture, enabling developers to decouple the UI from the Pega backend.

Integration Use Case:

• External frontend built in React displays a loan application form.

• The frontend calls Pega’s DX API to render views and submit user input.

Why It Matters:

• Enterprises increasingly adopt frontend frameworks like Angular, Vue, or React.

• LSA exams may reference modern architecture patterns like Headless UI or micro frontends.

5. Guardrails and Application Quality

Suggest adding a recurring section at the end of relevant modules explaining Guardrails:

What Are Guardrails:

• Pega’s design guidelines and best practices to ensure maintainable, upgrade-friendly applications.

Key Guardrail Tools:

• Warnings Panel: Lists violations like hardcoded values, deprecated rules, or missing documentation.

• App Quality Score (App Studio): Reflects adherence to guardrails on a scale.

Common Violations:

• Using hardcoded values instead of references or parameters.

• Creating flows with no SLA or with unreachable conditions.

• Rules that are not reused or violate modularity.

Why It Matters:

• Guardrail adherence is a grading metric in the LSA exam.

• Helps align technical implementation with enterprise standards.

6. Comparative Table of Flow Types

Add a comparison table summarizing flow design choices. This helps learners quickly choose the correct type during design or in exams.

Flow Type	Purpose	User Interaction	Concurrent Execution	Use Case Example
Screen Flow	Step-by-step user form	Yes	No	Customer registration
Process Flow	Automated background processing	No	Yes	Document verification
Subflow	Reusable logic segment	Optional	No	Manager approval
Parallel Flow	Execute tasks simultaneously	Yes	Yes	Background check + Credit check

Why It’s Useful:

• Promotes better flow design decisions.

• Makes it easier to choose between performance, reusability, and interactivity.

• Matches LSA exam scenarios where flow orchestration is tested.