[email protected]
0
[email protected]

Shopping cart

Subtotal:

$0
View cartCheckout

Back to PEGACPLSA23V1 Exam

This study plan combines focused learning strategies with the Pomodoro Technique (25-minute study sessions with short breaks) and Ebbinghaus Forgetting Curve (timely reviews to improve retention). The plan emphasizes a structured approach, dividing preparation into clear goals, tasks, and content focus areas over a 6-week period.

Overall Goal

Pass the PEGACPLSA23V1 Certification Exam by mastering:

  1. Pega Platform Design (and Extended Design)
  2. Application Design (and Extended Design)
  3. Data Model Design
  4. Reporting Design
  5. Security Design
  6. Deployment and Testing Design

Study Schedule

  • Duration: 6 weeks
  • Daily Study Hours: 3–4 hours (including review and short breaks).
  • Pomodoro Method:
    • Study for 25 minutes, followed by a 5-minute break.
    • After 4 sessions (2 hours), take a 20-minute break.
  • Forgetting Curve Reviews:
    • Day 1: Learn a topic.
    • Day 2: Review Day 1’s topic (quick summary).
    • Day 7: Weekly review of key points learned.
    • Day 21: Consolidate all material covered so far.

Pega Certified Lead System Architect (PEGACPLSA23V1) 6-Week Study Plan

Week 1: Pega Platform Design

Goals for Week 1:
  1. Understand the key principles of Pega Platform Design.
  2. Learn about Center-Out Architecture, Enterprise Class Structure (ECS), and performance optimization tools.
  3. Practice hands-on tasks to reinforce concepts.

Day 1: Center-Out Business Architecture

Learning Objectives:

  • Understand the concept of Center-Out Business Architecture: Microjourneys, Decisions, and Channels.

Tasks:

  1. Study Microjourneys and their role in breaking down processes.

    • Break down a Loan Application process into smaller Microjourneys such as “Initiate Loan,” “Review Application,” and “Approve Loan.”
    • Draw a flow diagram showing stages and outcomes for each Microjourney.

  2. Learn about business decisioning tools: Decision Tables, Decision Trees, and Predictive Models.

    • Document the differences between these tools with use-case examples.
    • Practice configuring a Decision Table in Pega.

  3. Multi-Channel Delivery:

    • Write a 1-page explanation of how Pega enables channels such as web, mobile, chatbots, and email.
    • Map an example: Display Loan Status using different channels (web and chatbot).

Review:

  • Recap Microjourneys, Decisions, and Channels.
  • Spend 10 minutes summarizing key points using flashcards.

Day 2: Enterprise Class Structure (ECS)

Learning Objectives:

  • Understand the Organizational, Division, Framework, and Implementation layers of ECS.

Tasks:

  1. Learn ECS best practices:

    • Study the purpose of each layer in the class hierarchy.
    • Document examples of reusable rules at each layer.

  2. Hands-on:

    • Create a simple ECS diagram for a sample company:
      • Organizational Layer: Reusable validation rules.
      • Division Layer: Regional-specific processes.
      • Framework Layer: Loan application framework.
      • Implementation Layer: Loan application for a specific country.

  3. Rule Reuse:

    • Identify 3 best practices for ensuring scalability and avoiding duplication in ECS.
    • Write a 300-word explanation.

Review:

  • Review your ECS diagram and notes.
  • Use a mind map to recall key layers and their purposes.

Day 3: Performance Optimization

Learning Objectives:

  • Learn about performance monitoring tools: Pega Predictive Diagnostic Cloud (PDC), Autonomic Event Services (AES).
  • Understand Declarative Processing and its advantages.

Tasks:

  1. Study PDC and AES:

    • Write an overview of how PDC monitors application health, including key metrics (e.g., slow queries, alert thresholds).
    • Explore the PDC dashboard in a sandbox environment (if possible).

  2. Declarative Processing:

    • Learn how Declare Expressions reduce redundant calculations.
    • Hands-on: Create a Declare Expression rule to calculate “Total Loan Amount” based on multiple inputs like Principal, Interest, and Fees.

  3. Optimize a Data Page:

    • Analyze a sample Data Page configuration and document performance issues.
    • Redesign the Data Page to load data more efficiently, using Node-level caching.

Review:

  • Recap the role of PDC, AES, and Declarative Processing.
  • Spend 15 minutes solving conceptual questions about optimization strategies.

Day 4: Deployment Options

Learning Objectives:

  • Understand cloud, on-premises, and hybrid deployment options.
  • Learn the basics of DevOps integration in Pega.

Tasks:

  1. Cloud vs On-Premises:

    • Write a comparison between Pega Cloud, on-premises, and hybrid deployments.
    • Identify 3 benefits of each approach.

  2. DevOps Integration:

    • Study how CI/CD pipelines work for automated deployments.
    • Sketch a pipeline with stages like Version Control, Build, Test, and Deploy.
    • Write down tools used in CI/CD (e.g., Jenkins, Azure DevOps).

  3. Hands-On:

    • Prepare a deployment package using Product Rules in Pega. Document the steps involved.

Review:

  • Spend 20 minutes reviewing key benefits and trade-offs of deployment options.

Day 5: Application Monitoring and Logging

Learning Objectives:

  • Learn about system logs, alert logs, and Admin Studio tools for monitoring health.

Tasks:

  1. Study Log Management:

    • Explore types of logs: System logs, alert logs, and error logs.
    • Write 3 scenarios where each log type is critical.

  2. Node Health Monitoring:

    • Go to Admin Studio and document features for monitoring nodes, agents, and queue processors.
    • Summarize the steps for analyzing node performance issues.

  3. Threshold Alerts:

    • Learn how to configure alerts for memory usage and slow database queries.

Hands-On Practice:

  • Generate a sample system log to understand its structure.

Review:

  • Summarize the key tools in Admin Studio and their uses in a checklist.

Day 6: Consolidation and Hands-On Practice

Goals:

  • Apply all concepts learned this week in a practical example.

Tasks:

  1. Create a simple Loan Application case:

    • Implement a Microjourney using ECS principles.
    • Optimize performance with Declarative Rules and efficient Data Pages.

  2. Monitor the Loan Application:

    • Use PDC or Admin Studio to simulate monitoring node health.
    • Analyze sample logs for errors and document solutions.

  3. Deployment Practice:

    • Package the application rules into a Product Rule for deployment.

Review:

  • Spend 30 minutes reviewing all notes, tasks, and diagrams from this week.

Day 7: Weekly Review

Goals:

  • Consolidate all learning from Week 1.
  • Identify any gaps and resolve doubts.

Tasks:

  1. Go through all diagrams and notes from the week.

    • Center-Out Architecture
    • ECS layers
    • Performance Optimization tools
    • Deployment options
    • Monitoring tools

  2. Flashcard Review:

    • Create flashcards for key concepts such as ECS layers, declarative rules, and monitoring tools.

  3. Practice Questions:

    • Solve 10–15 multiple-choice questions focused on Pega Platform Design.

  4. Self-Assessment:

    • Reflect on areas where you feel less confident and schedule additional reviews if needed.

Week 2: Application Design

Goals for Week 2:
  1. Master the concepts of Microjourney design, Case Management, and Pega Express Methodology.
  2. Learn how to build modular and reusable application components.
  3. Develop hands-on experience by designing case types, configuring SLAs, and implementing rule reuse strategies.

Day 8: Microjourney Design

Learning Objectives:

  • Understand how Microjourneys simplify business processes into smaller, manageable outcomes.
  • Learn the structure of stages, steps, and processes in a Microjourney.

Tasks:

  1. Study the anatomy of a Microjourney:

    • Define stages (major milestones) and steps (actions within stages).
    • Write an example of how a Loan Application Microjourney breaks into:
      • Stage 1: Submission (Steps: Collect data, validate input).
      • Stage 2: Review (Steps: Verify documents, assess risk).
      • Stage 3: Approval (Steps: Final approval, notify user).

  2. Draw a detailed flow diagram for the Loan Application process:

    • Use a tool (e.g., Visio, Draw.io, or a notebook).
    • Highlight decision points, assignments, and outcomes.

  3. Create a draft Case Type in Pega:

    • Define the case lifecycle stages and steps.
    • Include an optional action (e.g., “Edit Application” during the Review stage).

Review:

  • Summarize the key purpose of Microjourneys and document their benefits for modularity and agility.

Day 9: Case Management

Learning Objectives:

  • Learn how to manage case lifecycles using Parent/Child Cases, SLAs, and routing rules.

Tasks:

  1. Parent and Child Cases:

    • Design a Parent Case for “Loan Application” and Child Cases for:
      • Document Verification
      • Background Check
    • Write a document explaining when to use Parent-Child relationships.

  2. Service Level Agreements (SLAs):

    • Learn SLA components: Goal, Deadline, Passed Deadline actions.
    • Hands-On: Configure an SLA for “Document Verification” with the following settings:
      • Goal: 1 hour
      • Deadline: 4 hours
      • Escalation: Send an email notification if the SLA is breached.

  3. Routing Rules:

    • Create a routing rule to assign tasks to users based on roles:
      • Example: Assign “Review Documents” to the “Loan Officer” work queue.

Review:

  • Recap SLA configurations and routing strategies.
  • Document 3 scenarios where SLAs improve case performance.

Day 10: Pega Express Methodology

Learning Objectives:

  • Understand the phases of Pega Express: Discover, Prepare, Build, and Adopt.
  • Learn how to define and deliver an MVP (Minimum Viable Product).

Tasks:

  1. Study the Pega Express phases:

    • Write a 1-page explanation of each phase with real-world examples:
      • Discover: Identify Microjourneys, data, and personas.
      • Prepare: Design the case lifecycle, initial data, and key rules.
      • Build: Develop and test the application iteratively.
      • Adopt: Train users and roll out the MVP.

  2. Create an MVP outline for a Loan Application case:

    • Define the Microjourney, key milestones, and case types required for the MVP.
    • Include stages: Submission → Review → Approval.

  3. Hands-On Practice:

    • Use Pega to configure a draft MVP Case Type. Focus on submission and review stages.

Review:

  • Summarize the benefits of using Pega Express for rapid application delivery.

Day 11: Application Modularity

Learning Objectives:

  • Learn about rule specialization, rule reuse, and modularity in applications.

Tasks:

  1. Rule Specialization (Circumstancing):

    • Learn how to create circumstanced rules based on conditions.
    • Hands-On:
      • Circumstance a “Loan Approval” rule based on Loan Amount:
        • If LoanAmount > $100,000, use a specialized rule for high-value loan approvals.

  2. Reusable Rules and Templates:

    • Identify rules that can be reused across applications.
    • Hands-On: Create a reusable UI Section Template for capturing customer details (e.g., Name, Email, Phone Number).

  3. Document modularity best practices:

    • Write 3 strategies for creating reusable application components.

Review:

  • Recap modular design, circumstancing, and reusable templates.

Day 12: Rule Templates and Patterns

Learning Objectives:

  • Learn how to use templates and patterns to standardize application design.

Tasks:

  1. Study the purpose of rule templates in Pega:

    • Explore Section Templates, Case Templates, and validation patterns.

  2. Hands-On:

    • Create a Section Template for Loan Applications:
      • Include input fields for Customer Name, Loan Amount, and Loan ID.
    • Use the template in a new Loan Application case.

  3. Research Patterns:

    • Identify design patterns in Pega applications that enhance reusability and performance.
    • Write down examples for validation and routing patterns.

Review:

  • Summarize the advantages of templates and patterns for large-scale applications.

Day 13: Hands-On Practice

Goals:

  • Apply all concepts learned this week to build a modular and functional case type.

Tasks:

  1. Build a complete Loan Application case in Pega:

    • Include Parent and Child Cases.
    • Implement an SLA for document verification.
    • Route assignments to appropriate work queues.
    • Add circumstanced rules for high-value approvals.

  2. Optimize the application:

    • Use reusable templates for UI sections.
    • Ensure the design follows Pega modularity principles.

  3. Test the Case Type:

    • Run through all stages of the case. Verify that SLAs and routing rules function as expected.

Review:

  • Document your configuration steps and challenges encountered.

Day 14: Weekly Review

Goals:

  • Consolidate knowledge from Week 2 and reinforce understanding through practice questions.

Tasks:

  1. Summarize:

    • Microjourneys, Case Management (Parent/Child Cases, SLAs, Routing), Pega Express, Rule Reuse, and Templates.
    • Use mind maps, notes, and flashcards for quick recall.

  2. Practice:

    • Solve 15–20 multiple-choice questions related to:
      • Microjourneys
      • Case lifecycle management
      • Rule modularity and specialization

  3. Reflect:

    • Identify any weak areas and schedule extra revision time if needed.

End of Week 2

By the end of Week 2, you will have:

  1. Designed complete Microjourneys and case lifecycles with SLAs and routing rules.
  2. Understood how to use Pega Express methodology for quick MVP delivery.
  3. Configured reusable rules, templates, and modular components to streamline application design.

Week 3: Data Model Design

Goals for Week 3
  1. Master data modeling concepts, including data relationships, data classes, and properties.
  2. Understand Data Pages and how to configure data scope and refresh strategies.
  3. Learn how to integrate data with external systems (REST/SOAP connectors).
  4. Gain hands-on experience creating and validating a robust data model in Pega.

Day 15: Data Relationships

Learning Objectives:

  • Understand how to define and manage One-to-One, One-to-Many, and Many-to-Many relationships in Pega.

Tasks:

  1. Learn Data Relationships:

    • Study the three types of data relationships and their use cases.
    • Write short notes on how each relationship applies in a Loan Application system:
      • One-to-One: Loan Application to Customer Profile.
      • One-to-Many: Loan Application to Supporting Documents.
      • Many-to-Many: Loan Officers managing multiple loan applications.

  2. Hands-On Task:

    • Create a Parent Case (Loan Application) and set up a One-to-Many relationship with child cases (Document Verification).
    • Define properties for both cases and establish proper relationships in the data model.

  3. Document Design:

    • Draw a diagram representing the relationships and hierarchy of data classes for Loan Application.

Review:

  • Spend 15 minutes reviewing relationships using your notes and diagrams.
  • Test your understanding by answering conceptual questions: "When would you use Many-to-Many relationships?"

Day 16: Data Classes and Properties

Learning Objectives:

  • Learn how to define data classes and properties to organize and structure data effectively.

Tasks:

  1. Understand Data Classes:

    • Study how Pega uses data classes to manage data and how it differs from case classes.
    • Write a list of reusable data classes for a Loan Application:
      • CustomerDetails
      • LoanDetails
      • SupportingDocuments

  2. Hands-On Task:

    • Create the following data classes in Pega:
      • CustomerDetails: Name, Address, PhoneNumber.
      • LoanDetails: LoanID, LoanAmount, LoanStatus.
      • SupportingDocuments: DocumentName, DocumentType, UploadDate.

  3. Define Properties:

    • Configure properties in each data class with appropriate types:
      • Text, Integer, Date, and Picklists.
    • Add validation rules for properties: e.g., LoanAmount > 1000.

  4. Data Transform:

    • Write a Data Transform to map CustomerDetails into the LoanDetails class.

Review:

  • Summarize the key differences between case classes and data classes.
  • Test the configuration to verify all properties are mapped correctly.

Day 17: Data Pages and Scope

Learning Objectives:

  • Learn how to configure Data Pages for managing data retrieval and caching.
  • Understand Data Page scope: Thread, Requestor, and Node.

Tasks:

  1. Learn Data Page Scope:

    • Study when to use Thread-level, Requestor-level, and Node-level scopes.
    • Write a 300-word explanation of scope differences with examples.

  2. Hands-On Task:

    • Create Data Pages for the following scenarios:
      • Thread Scope: Fetch customer-specific data when a user opens a loan application.
      • Node Scope: Load interest rates that are static across all users.

  3. Refresh Strategies:

    • Implement refresh conditions for the Data Pages:
      • Manual refresh.
      • Reload if older than a specified interval.

  4. Testing:

    • Test the Data Pages using the Clipboard tool to check the loaded data and refresh behavior.

Review:

  • Recap Data Page scopes and write down scenarios for when to use each.
  • Verify your understanding with practice exercises.

Day 18: Data Integration

Learning Objectives:

  • Learn how to connect Pega with external systems using REST and SOAP connectors.

Tasks:

  1. Study REST Connectors:

    • Learn how to configure a REST connector to fetch external data.
    • Write notes on how REST APIs use HTTP methods (GET, POST, PUT, DELETE).

  2. Hands-On Task:

    • Configure a REST connector to retrieve customer details from an external endpoint:
      • Endpoint: /api/customers/{customerID}.
      • Map the response fields (Name, PhoneNumber, Address) into your CustomerDetails class.

  3. Testing:

    • Test the REST connector using the Pega Connector Simulator. Verify the response.

  4. SOAP Connectors:

    • Write a summary of when SOAP is used instead of REST.
    • Explore configuring a SOAP connector (optional).

Review:

  • Summarize the steps to configure REST connectors and note the difference between REST and SOAP.

Day 19: Data Validation

Learning Objectives:

  • Learn how to implement data validation rules and Edit Validate rules to ensure data integrity.

Tasks:

  1. Validation Rules:

    • Study the types of validation rules: Required Fields, Ranges, and Custom Logic.
    • Hands-On Task:
      • Create a validation rule to ensure LoanAmount is greater than 1,000.

  2. Edit Validate Rules:

    • Learn how to write custom logic for input validation.
    • Hands-On Task:
      • Write an Edit Validate rule to ensure PhoneNumber follows a specific format (e.g., XXX-XXX-XXXX).

  3. Testing:

    • Test the validation rules by entering incorrect and correct data values. Document the behavior.

Review:

  • Summarize how validation rules ensure data accuracy.
  • Write notes about the difference between Validation Rules and Edit Validate Rules.

Day 20: Hands-On Practice

Goals:

  • Apply all the concepts learned throughout the week to build a robust data model.

Tasks:

  1. Data Classes and Relationships:

    • Create Parent and Child data classes (LoanDetails → SupportingDocuments).

  2. Data Pages:

    • Configure a Data Page with a REST connector to fetch customer details.

  3. Validation Rules:

    • Add Edit Validate rules and test different scenarios.

  4. Testing:

    • Verify all components:
      • Data relationships
      • Data Page configurations
      • Validation rules

Review:

  • Reflect on the steps taken to build a data model and document any challenges faced.

Day 21: Weekly Review

Goals:

  • Consolidate all learning from Week 3 and identify weak areas for further improvement.

Tasks:

  1. Summarize Key Topics:

    • Data Relationships
    • Data Classes and Properties
    • Data Pages and Scope
    • REST Connectors
    • Validation Rules

  2. Flashcard Review:

    • Create flashcards for Data Page scopes, connector configurations, and validation types.

  3. Practice Questions:

    • Solve 15–20 multiple-choice questions focusing on data relationships, Data Pages, and integration.

  4. Hands-On Recap:

    • Run your Loan Application system end-to-end:
      • Verify that data integrates correctly, validation rules trigger, and Data Pages load properly.

  5. Self-Assessment:

    • Reflect on weak areas and schedule additional time next week for revision if needed.

End of Week 3

By the end of Week 3, you will have:

  1. Built a complete data model with data classes, properties, and relationships.
  2. Configured and tested Data Pages with appropriate scopes and refresh strategies.
  3. Integrated Pega with an external system using REST connectors.
  4. Implemented validation rules to ensure data integrity.

Week 4: Reporting Design

Goals for Week 4
  1. Learn how to configure Report Definitions, including sorting, filtering, and grouping.
  2. Understand List Reports, Summary Reports, and how to visualize data with charts.
  3. Practice optimizing reports for performance using indexing and declarative techniques.
  4. Gain hands-on experience building and optimizing various reports to support business requirements.

Day 22: Report Definitions

Learning Objectives:

  • Understand the purpose of Report Definitions to retrieve, filter, and display application data.
  • Learn the components: Columns, Sorting, Grouping, and Filters.

Tasks:

  1. Learn Report Definition Components:

    • Study how to configure report columns, apply sorting, and add filters.
    • Document the difference between static and dynamic filters.

  2. Hands-On Task 1:

    • Create a List Report for a Loan Application system:
      • Columns: Loan ID, Customer Name, Loan Amount, and Loan Status.
      • Add sorting by Loan Amount in descending order.
      • Apply filters to display only loans with a Status = Approved.

  3. Hands-On Task 2:

    • Add Grouping and Aggregation:
      • Group loans by Loan Officer and display the SUM of Loan Amount.
      • Verify that grouping displays totals accurately.

  4. Test the Report:

    • Run the report and validate the output against sample data.
    • Check sorting, grouping, and filter behavior.

Review:

  • Spend 15 minutes summarizing Report Definition components and their functions.

Day 23: List Reports and Summary Reports

Learning Objectives:

  • Learn the difference between List Reports (tabular reports) and Summary Reports (aggregated reports).

Tasks:

  1. List Reports:

    • Study their purpose: displaying raw data in a tabular format.
    • Hands-On: Create a List Report to show all pending loan applications:
      • Columns: Loan ID, Customer Name, Submission Date.
      • Add a filter for Status = Pending.

  2. Summary Reports:

    • Learn how to create reports that aggregate data using functions like SUM, AVG, MIN, and MAX.
    • Hands-On:
      • Create a Summary Report showing:
        • Total Loan Amount grouped by Loan Status.
        • Average Loan Amount for loans Approved.

  3. Review Visual Differences:

    • Compare the outputs of List and Summary Reports.
    • Document 3 key use cases for each report type.

Review:

  • Summarize the differences and uses of List Reports vs. Summary Reports.

Day 24: Chart Visualizations

Learning Objectives:

  • Learn how to visualize report data using charts like bar charts, line graphs, and pie charts.

Tasks:

  1. Study Chart Types:

    • Understand when to use different chart types:
      • Bar Chart: Comparisons across categories.
      • Line Chart: Trends over time.
      • Pie Chart: Percentages and proportions.

  2. Hands-On Task 1:

    • Create a Bar Chart report that shows Loan Status (Approved, Pending, Rejected) and the count of applications for each.

  3. Hands-On Task 2:

    • Create a Pie Chart to display the proportion of loans Approved vs Pending vs Rejected.

  4. Hands-On Task 3:

    • Build a Line Chart to show the trend of loan submissions over the past 6 months.

  5. Test and Validate:

    • Run all chart-based reports and ensure data visualization is correct.

Review:

  • Spend 15 minutes summarizing the chart types and documenting when to use each.

Day 25: Report Performance Optimization

Learning Objectives:

  • Learn techniques to optimize the performance of reports and avoid long-running queries.

Tasks:

  1. Indexing and Declarative Indexing:

    • Study how indexes improve database query performance.
    • Hands-On Task: Add an index to the Loan Amount property and measure report performance before and after indexing.

  2. Pagination and Data Limiting:

    • Implement pagination to limit the number of rows displayed in a report (e.g., display 20 rows per page).
    • Hands-On: Apply a data limit to ensure the report retrieves a maximum of 100 rows.

  3. Avoid Performance Issues:

    • Identify scenarios where reports could cause performance problems (e.g., unfiltered queries, large datasets).
    • Write down 3 best practices for designing optimized reports.

  4. Validation:

    • Test report performance using large datasets to ensure the optimizations work as expected.

Review:

  • Recap report optimization strategies and summarize key performance tuning techniques.

Day 26: Hands-On Practice

Goals:

  • Build comprehensive reports that address both functional and performance requirements.

Tasks:

  1. Create the following reports for a Loan Application system:

    • A List Report showing all approved loans sorted by Loan Amount.
    • A Summary Report with a Bar Chart visualizing the total Loan Amount by Loan Officer.
    • A Pie Chart Report showing the breakdown of loan statuses (Approved, Pending, Rejected).

  2. Optimize the reports:

    • Add property indexes for frequently queried fields (Loan Status, Loan Amount).
    • Configure pagination for large reports.

  3. Test all reports to ensure they display correct and optimized results.

Review:

  • Reflect on the report-building process and document challenges and solutions.

Day 27: Weekly Consolidation

Goals:

  • Consolidate all the concepts and tasks from the week.

Tasks:

  1. Summarize Learning:

    • Review Report Definitions, List Reports, Summary Reports, chart visualizations, and optimization techniques.
    • Use mind maps or diagrams to consolidate your notes.

  2. Flashcards:

    • Create flashcards for key terms: Report Types, Indexing, Filtering, Grouping, Chart Types, and Pagination.

  3. Practice:

    • Solve 15–20 practice questions on reporting concepts, including optimization and visualizations.

  4. Hands-On Recap:

    • Rerun all reports you created this week and validate their output for correctness.

Day 28: Weekly Review and Self-Assessment

Goals:

  • Reinforce understanding and identify areas for further practice.

Tasks:

  1. Self-Quiz:

    • Complete a short quiz with 20 multiple-choice and scenario-based questions on Reporting Design.

  2. Review Reports:

    • Revisit all hands-on reports:
      • Verify performance optimization.
      • Test data accuracy and filters.

  3. Reflect:

    • Write down areas where you need improvement. Schedule additional practice time if needed.

End of Week 4

By the end of Week 4, you will have:

  1. Learned how to build List Reports, Summary Reports, and visual charts to display data effectively.
  2. Practiced optimizing report performance using techniques like indexing, pagination, and data limiting.
  3. Gained hands-on experience creating reports that meet business requirements and ensure performance.

Week 5: Security Design

Goals for Week 5
  1. Learn how to secure Pega applications using authentication, authorization, and data security.
  2. Configure user access using Access Groups, Roles, and Privileges.
  3. Implement data protection measures, including Row-Level Security, Field-Level Security, and Encryption.
  4. Explore auditing and compliance mechanisms, including Audit Trails and System Logging.

Day 29: Authentication

Learning Objectives:

  • Understand how to configure different authentication mechanisms: LDAP, SAML SSO, OAuth 2.0, and Multi-Factor Authentication (MFA).

Tasks:

  1. Learn Authentication Options:

    • Study the purpose and use cases for LDAP, SAML SSO, and OAuth 2.0.
    • Write a comparison of each method:
      • LDAP for directory-based authentication.
      • SAML for Single Sign-On (SSO) with external identity providers.
      • OAuth 2.0 for API authentication.

  2. Hands-On Task 1:

    • Configure a SAML SSO Authentication Service in Pega:
      • Set up an Identity Provider (IdP) like Okta or Azure AD.
      • Map user attributes (e.g., email) to the Operator ID in Pega.

  3. Hands-On Task 2:

    • Simulate OAuth 2.0 for API authentication:
      • Set up a REST integration requiring OAuth-based access tokens.

  4. Multi-Factor Authentication:

    • Document how MFA adds an extra security layer (e.g., OTPs or biometrics).

Review:

  • Summarize authentication methods and note their real-world use cases.
  • Spend 15 minutes writing out the steps to configure SAML SSO and OAuth.

Day 30: Authorization – Access Groups and Roles

Learning Objectives:

  • Learn how to control user access through Access Groups, Roles, and Privileges.

Tasks:

  1. Access Groups:

    • Study how Access Groups link users to applications and portals.
    • Hands-On Task:
      • Create two Access Groups:
        • LoanOfficerAccessGroup: Grants access to Loan Application Case Manager Portal.
        • LoanAdminAccessGroup: Grants admin-level access to all loan rules and configurations.

  2. Access Roles and Control:

    • Learn how roles and ACLs define permissions (Read, Write, Delete, Execute).
    • Hands-On Task:
      • Configure an Access Role for Loan Officers:
        • Grant read-only access to approved loan cases.
        • Restrict deletion access.

  3. Privileges:

    • Study how privileges control access to specific rules.
    • Hands-On Task:
      • Add a Privilege to restrict access to “Approve High-Value Loans” Flow Action.
      • Test access for users with and without the privilege.

Review:

  • Summarize Access Groups, Roles, and Privileges.
  • Test user scenarios to verify access permissions.

Day 31: Data Security – Row-Level and Field-Level Security

Learning Objectives:

  • Understand how to secure data at the record level (Row-Level) and field level (Field-Level).

Tasks:

  1. Row-Level Security:

    • Study how Access Control Policies filter data dynamically based on user roles.
    • Hands-On Task:
      • Create a Row-Level Security Rule:
        • Loan Officers can only view loans assigned to them.
        • Managers can view all loans in their department.

  2. Field-Level Security:

    • Learn how to mask or hide specific fields for unauthorized users.
    • Hands-On Task:
      • Mask the “SSN” (Social Security Number) field for non-admin users.
      • Test the behavior for users with different roles.

  3. Testing Security Rules:

    • Simulate user scenarios to verify:
      • Loan Officer cannot access another officer’s loans.
      • SSN field is masked for Loan Officers but visible to Admins.

Review:

  • Document the configuration steps for Row-Level and Field-Level Security.
  • Write 3 benefits of implementing fine-grained data security.

Day 32: Encryption

Learning Objectives:

  • Learn how to implement encryption at rest and encryption in transit to protect sensitive data.

Tasks:

  1. Encryption at Rest:

    • Study how Pega encrypts database fields using Keystore configurations.
    • Hands-On Task:
      • Configure encryption for the SSN property:
        • Use a Keystore rule with a 256-bit encryption key.

  2. Encryption in Transit:

    • Learn how to enable HTTPS/TLS for secure data transfer.
    • Hands-On Task:
      • Secure a REST integration by enabling SSL (HTTPS) on the endpoint URL.

  3. Validate Encryption:

    • Test that sensitive data remains encrypted at rest and while transmitted to/from external systems.

Review:

  • Summarize encryption types and explain their role in securing data.
  • Document the steps for configuring encryption in Pega.

Day 33: Audit and Compliance

Learning Objectives:

  • Learn how to track user actions and ensure compliance using Audit Trails and Logging.

Tasks:

  1. Audit Trails:

    • Study the importance of audit trails for tracking case changes and user activities.
    • Hands-On Task:
      • Enable Field-Level Auditing for Loan Amount and Loan Status properties.
      • Test by modifying the properties and reviewing the audit trail.

  2. System Logs:

    • Learn about system logs (PegaRULES.log, PegaSecurity.log) and their purpose.
    • Hands-On Task:
      • Simulate a failed login attempt and review the PegaSecurity.log for details.

  3. Compliance:

    • Write notes on how audit trails and logging support regulatory compliance (e.g., GDPR, HIPAA).

Review:

  • Summarize key tools for auditing and logging in Pega.
  • Reflect on the importance of compliance for enterprise applications.

Day 34: Hands-On Practice

Goals:

  • Apply all security concepts learned this week to configure a secure Loan Application system.

Tasks:

  1. Authentication:

    • Configure SAML SSO for user authentication.

  2. Authorization:

    • Assign Access Groups and Roles to Loan Officers and Admins.
    • Add Privileges to restrict specific actions (e.g., approving high-value loans).

  3. Data Security:

    • Implement Row-Level Security so that Loan Officers can only see their own loan cases.
    • Mask SSN fields for unauthorized users.

  4. Encryption:

    • Enable encryption for sensitive data fields like SSN.

  5. Auditing:

    • Enable Audit Trail tracking for loan case updates.

Review:

  • Test all configurations using different user roles.
  • Document the steps, challenges, and outcomes.

Day 35: Weekly Review and Assessment

Goals:

  • Consolidate all knowledge gained this week and reinforce weak areas.

Tasks:

  1. Summarize Key Topics:

    • Authentication methods (LDAP, SAML, OAuth).
    • Authorization (Access Groups, Roles, Privileges).
    • Row-Level and Field-Level Security.
    • Encryption and Auditing.

  2. Flashcard Review:

    • Create flashcards for authentication methods, security rules, and encryption configurations.

  3. Practice Questions:

    • Solve 20 multiple-choice and scenario-based questions related to:
      • User access configurations.
      • Security rules and data protection measures.

  4. Hands-On Recap:

    • Run end-to-end security tests to verify all configurations for Loan Officers and Admins.

End of Week 5

By the end of Week 5, you will have:

  1. Configured robust authentication and authorization mechanisms using Access Groups, Roles, and Privileges.
  2. Implemented fine-grained Row-Level Security, Field-Level Security, and encryption for sensitive data.
  3. Enabled audit trails and system logs to monitor user actions and support compliance.
  4. Gained practical experience securing a Loan Application system end-to-end.

Week 6: Deployment and Testing Design

Goals for Week 6
  1. Learn how to configure and manage deployment pipelines using CI/CD tools.
  2. Understand rule migration using Product Rules for efficient deployment.
  3. Master testing strategies, including PegaUnit Testing, UI Testing, and Performance Testing.
  4. Gain hands-on experience implementing error handling and rollback strategies for deployment failures.

Day 36: Deployment Pipelines and CI/CD

Learning Objectives:

  • Understand how Continuous Integration (CI) and Continuous Deployment (CD) automate application delivery.
  • Learn the role of tools like Jenkins, Azure DevOps, and Pega Deployment Manager.

Tasks:

  1. Learn CI/CD Fundamentals:

    • Study the concepts of CI/CD: Build, Test, Deploy.
    • Write down the stages of a CI/CD pipeline:
      • Source Control → Build → Test → Package → Deploy.

  2. Hands-On Task 1:

    • Sketch a sample CI/CD pipeline for a Loan Application system:
      • Stage 1: Export rules from Development using Product Rules.
      • Stage 2: Build and validate rules using automated tests (PegaUnit).
      • Stage 3: Deploy rules to the Staging environment.

  3. Hands-On Task 2:

    • Set up a Jenkins pipeline for automated deployment:
      • Define tasks for export, test, and import processes.
      • Simulate a rule migration from Development to Staging.

  4. Test the Pipeline:

    • Validate deployment logs to confirm successful migration.

Review:

  • Write down 3 benefits of CI/CD for Pega applications.
  • Summarize the steps involved in setting up an automated pipeline.

Day 37: Rule Migration with Product Rules

Learning Objectives:

  • Learn how to package and migrate rules using Product Rules.

Tasks:

  1. Understand Product Rules:

    • Study the components of Product Rules:
      • RuleSet versions, data instances, access groups, and attachments.

  2. Hands-On Task 1:

    • Create a Product Rule to package the Loan Application system:
      • Include: Case Types, Data Pages, SLAs, Access Groups, and UI templates.

  3. Hands-On Task 2:

    • Export the Product Rule as a ZIP file.

  4. Rule Import:

    • Import the Product Rule into a new environment (e.g., Staging).
    • Validate rule deployment by checking rule availability and functionality.

  5. Testing:

    • Document any migration errors and analyze logs for root causes.

Review:

  • Summarize the role of Product Rules in rule migration.
  • List the steps for creating, exporting, and importing Product Rules.

Day 38: Testing Strategies – PegaUnit Testing

Learning Objectives:

  • Learn how to create and execute PegaUnit Test Cases to validate rules.

Tasks:

  1. Study PegaUnit:

    • Understand how PegaUnit tests automate rule validation.
    • Learn which rules can be tested (e.g., Data Transforms, Activities, Flows).

  2. Hands-On Task 1:

    • Create a PegaUnit Test Case for a Data Transform:
      • Input: LoanAmount = 75,000, Income = 100,000.
      • Expected Output: Eligible = true.

  3. Hands-On Task 2:

    • Write a test case to validate an Activity rule that calculates interest for loans.

  4. Automate Testing:

    • Configure a Jenkins job to run PegaUnit test cases automatically after deployment.

Review:

  • Summarize the benefits of automated testing in Pega.
  • Document the steps to create, run, and validate PegaUnit tests.

Day 39: UI Testing and Performance Testing

Learning Objectives:

  • Learn how to test Pega applications for UI functionality and performance under load.

Tasks:

  1. UI Testing with Selenium:

    • Study how Selenium automates UI testing.
    • Hands-On Task:
      • Write a Selenium script to test the “Submit Loan Application” flow:
        • Navigate to the form.
        • Input Loan Amount and Customer Name.
        • Submit the form and verify the success message.

  2. Performance Testing with JMeter:

    • Learn how to simulate load testing using Apache JMeter.
    • Hands-On Task:
      • Create a JMeter test plan to simulate 50 users submitting loan applications concurrently.
      • Measure response time, throughput, and error rates.

  3. Analyze Results:

    • Analyze JMeter reports for bottlenecks and slow responses.
    • Write down findings and suggest improvements.

Review:

  • Recap UI and performance testing tools, focusing on their use cases.
  • Summarize the results of your performance test.

Day 40: Error Handling and Rollback Strategies

Learning Objectives:

  • Learn how to implement error handling and rollback strategies for failed deployments.

Tasks:

  1. Study Rollback Strategies:

    • Understand manual and automated rollback options in Pega.
    • Write down a rollback plan for the Loan Application deployment.

  2. Hands-On Task:

    • Simulate a failed deployment in Staging:
      • Introduce an invalid rule or dependency error.
    • Configure an automated rollback in Jenkins:
      • Revert to the previous stable Product Rule version.

  3. Error Logging:

    • Analyze deployment errors using PegaRULES.log.
    • Write a step-by-step approach to identify and fix deployment issues.

Review:

  • Summarize rollback strategies and their importance.
  • Document a real-world rollback scenario with steps.

Day 41: Hands-On Practice

Goals:

  • Apply all deployment and testing concepts learned this week to an end-to-end solution.

Tasks:

  1. Build a Deployment Pipeline:

    • Automate deployment using Jenkins with the following steps:
      • Export Product Rule → Run PegaUnit tests → Import to Staging.

  2. Testing:

    • Run PegaUnit test cases to validate:
      • Data Transforms
      • Activities
      • SLAs

  3. UI and Performance Testing:

    • Execute Selenium scripts to test UI flows.
    • Run JMeter tests to analyze system performance.

  4. Error Simulation and Rollback:

    • Introduce an error during deployment and test rollback automation.

Review:

  • Document the entire deployment and testing process, including configurations, outcomes, and challenges.

Day 42: Final Review and Mock Exam

Goals:

  • Consolidate all knowledge from Weeks 1–6 and identify weak areas.
  • Test readiness through a mock exam.

Tasks:

  1. Summarize Key Topics:

    • Review notes, diagrams, and hands-on tasks from all previous weeks.
    • Focus on:
      • Deployment Pipelines
      • Testing Strategies
      • Rollback and Error Handling

  2. Mock Exam:

    • Take a full-length PEGACPLSA23V1 practice exam (80–100 questions).
    • Identify weak areas and review related topics.

  3. Self-Assessment:

    • Reflect on your performance and understanding of key concepts.
    • Spend 1–2 hours revisiting weak areas.

End of Week 6

By the end of Week 6, you will have:

  1. Configured CI/CD pipelines for automated deployment.
  2. Mastered PegaUnit Testing, UI Testing, and Performance Testing.
  3. Implemented error handling and rollback strategies for deployment failures.
  4. Validated your preparation through a mock exam and focused reviews.

Final Notes

Congratulations on completing the 6-week PEGACPLSA23V1 study plan! By following this plan, you’ve built a strong foundation, gained hands-on experience, and practiced exam-level questions. Remember to:

  • Review weak areas regularly.
  • Take additional mock exams for confidence.
  • Stay calm and confident during the actual exam.

You’re now fully prepared to achieve success in the PEGACPLSA23V1 certification!