Pega Sandbox

Category: Uncategorized

  • How to Import and Map Data, Pega Course for Beginners

    How to Import and Map Data, Pega Course for Beginners

    Welcome back! 👋
    In this tutorial, we’ll walk through three essential Pega skills you’ll use in almost any real application:

    1. Importing a CSV file into a Data Type
    2. Searching and displaying records using a Data Page / Data Type
    3. Creating an Auto-Complete field with visibility conditions

    Let’s get started.

    1. Importing CSV Data into a Pega Data Type

    First, open the Data Type you created in a previous lesson.
    We’ll be importing a CSV file into it—make sure you have your file ready.

    Step 1 — Import the CSV

    1. Open the Data Type.
    2. Go to the Records tab.
    3. Click Import and upload your CSV file.
    4. Click Next.

    Step 2 — Map Source to Target Properties

    Pega will display each column from the CSV.
    Map each one to the correct target property, for example:

    • first_name → FirstName
    • last_name → LastName

    (Complete all mappings based on your CSV.)

    Step 3 — Configure Import Options

    You can choose how Pega updates existing records:

    • Always update
    • Update if blank
    • Update if source is not blank

    For this example, select Always update.

    Step 4 — Match Existing Records (Optional)

    If your Data Type already contains data, you can match rows by a unique ID.

    We do not have IDs in this example, so we’ll select FirstName as the match key.

    Click Next.

    Step 5 — Validate and Import

    Give the import a name, then:

    • Validate the file
    • Confirm there are no errors
    • Click Finish

    Your Data Type will now show all imported records—hundreds of rows ready to use!
    This is extremely useful when populating lists such as countries, states, cities, or any reference table.

    2. Building the Customer Search Auto-Complete

    Now let’s go back to our case flow.

    We’ll create the first assignment form where users search for an existing customer.
    If the customer isn’t found, we’ll later add a button to create one.

    Step 1 — Open the Section

    1. Open the Flow Action.
    2. Open the Section rule.
    3. Switch to the Full Section Editor.

    This is where we build the customer search UI.

    Step 2 — Add an Auto-Complete Field

    1. From the palette, go to Data Capture → Auto Complete.
    2. Drop an auto-complete field on your form.
    3. Set the Target Property (create a new property if needed).

    Step 3 — Use a Data Source

    Auto-completes can source from:

    • A data page
    • A clipboard page
    • A report definition
    • A property

    Because our customer data is stored in a Data Type, we will use a Data Page List.

    ⚠️ Important: A Page List Data Page must be used to return multiple results.
    A single-record Data Page only returns one item based on a parameter, so it won’t work for autocomplete.

    Step 4 — Select the Data Page List

    Choose the Data Page List created from your Data Type.

    Then configure the search results:

    • Search field: FirstName
    • Display fields: First Name, Last Name
    • Identifier: .pyGUID (the unique ID)

    Step 5 — Add the Hidden Customer ID Field

    Create a property to store the selected ID.

    When the user picks a name from autocomplete, we’ll capture the GUID silently.

    Now save the section and test it.

    3. Testing the Auto-Complete Search

    Open the User Portal and create a new case.

    Start typing in the Customer field:

    • Type C → Suggestions appear
    • If no exact match exists, it shows similar names
    • Example: Typing “Cri” may show Cristian

    This works perfectly for large datasets.
    Avoid dropdowns when you have hundreds of rows—autocomplete is the correct approach.

    4. What’s Next? Visibility Conditions

    Now that customer selection works, the next step (in a future tutorial) is adding conditional fields.

    For example:

    • Show address fields only after a customer has been selected
    • Reveal a section only when the customer is new

    We will configure visibility based on the selected customer’s ID or property values.

    ✨ Final Thoughts

    In this tutorial, you learned how to:

    ✔ Import CSV data into a Pega Data Type
    ✔ Map and validate records during import
    ✔ Build an auto-complete search field using a Data Page List
    ✔ Capture the selected record’s unique ID
    ✔ Test your search functionality in the User Portal

    These skills are essential for building real-world Pega applications using best practices.

  • Pega Constellation: Save Data to a Data Type (Full Beginner Guide)

    Pega Constellation: Save Data to a Data Type (Full Beginner Guide)

    Welcome back! In today’s tutorial, we will continue building our application. Specifically, we will:

    • Create an optional action to allow users to add a new customer
    • Configure the UI to capture customer information
    • Save the data into a data type and create a new record in the database
    • Fix common mistakes and review troubleshooting tips

    Let’s get started.

    1. Creating the Optional Action

    So far, we have only built our Customer Search feature. Now we want users to have the option to create a new customer if the search doesn’t return a result.

    To create an optional action:

    1. Go to the Case Life Cycle panel on the left side.
    2. On the right panel, find Optional Actions.
    3. You can add:
      • A single-step form
      • A multi-step form
      • A process

    For this tutorial, I created a process that includes a form for entering new customer details.

    2. Creating the Flow Action and UI Section

    Inside the optional action process, we created a flow action, and inside that flow action we added a section that contains the customer fields.

    I kept the form simple with just a few fields so it’s not too cluttered. The values entered here will be used to create a new customer record in the database.

    3. Preparing the Data Structure

    To save data into a data type, Pega requires a single page property mapped to the class of your data type.

    You can create this by navigating to:

    App Explorer → Data Model → Property → New Property

    • Set the property type to Page
    • In Page Definition, enter the class of your customer data type

    We will use this single page later in our save operation.

    4. Using the “Save Data Page” Automation Shape

    Initially, I mistakenly selected Load Data Page, but for saving we need the Save Data Page automation shape.

    To configure it:

    1. In the flow, remove the incorrect shape (if needed).
    2. Add Save Data Page from the Automation palette.
    3. Open the shape and choose the page property associated with your data type.
    4. Select the identifier that will be used as the record key (e.g., CustomerID).

    5. Creating the Data Transform (Mapping Values)

    We now need a Data Transform to map values from the UI into the data page before saving them.

    Steps:

    1. Create a new Data Transform (e.g., CreateNewCustomer).
    2. Generate a unique key using:
      @pxGenerateUniqueID()
      This will populate the record ID automatically.
    3. Map all the form fields (source) to the customer data type properties (target).
    4. Save the rule.

    6. Testing the Flow (First Attempt)

    At this point, I tested the functionality, but noticed an issue:
    The optional action wasn’t appearing in the case.

    This happened because I was using the UI Kit theme, which lacks certain newer UI features.

    7. Switching the Application Theme to Cosmos

    To fix that:

    1. Open the Application rule.
    2. Change the UI theme to Theme-Cosmos (latest version).
    3. Save the rule.
    4. Open the Skin rule and change inheritance to a Cosmos skin.
    5. Save and log back in.

    Now the optional actions show correctly in the portal.

    8. Fixing the Optional Action Label

    Inside the flow action rule, update the Label to something meaningful like Create New Customer.

    Refresh the portal, and the new label appears.

    9. Saving the New Customer Record

    Enter the customer details in the optional action form and click Submit.

    Initially, I made another mistake—trying to create a separate property and link it manually.
    The correct approach is:

    1. Use a savable data page
    2. Set the Data Source to a Data Transform
    3. Map properties from pyWorkPage to the data type
    4. Generate the ID in the Data Transform

    10. Correct Savable Data Page Setup

    A proper configuration includes:

    Data Page

    • Structure: Page
    • Scope: Thread
    • Data Source: Data Transform
    • Parameters: Include the record ID (e.g., CustomerID)

    Data Transform

    • Add pyWorkPage under Pages and Classes
    • Map:
      • Form fields → Data type properties
      • Auto-generated ID → Identifier property

    Once saved, this Data Page can be invoked:

    • From a flow action (post-processing)
      or
    • From a Save Data Page automation shape

    Both work.

    11. Testing the Final Working Configuration

    1. Create a new case.
    2. Open Create New Customer.
    3. Enter the information.
    4. Submit the form.

    Open your data type, click Records, and you will see the new row created successfully.

    This confirms that:

    • The Data Transform ran correctly
    • The savable data page executed
    • The database updated without errors

    12. Troubleshooting Tips

    • Use the Clipboard to inspect the data page and verify that:
      • Parameters were passed
      • No errors occurred
      • The record key was generated
    • Check Pages & Classes if a Data Transform can’t resolve properties
    • Ensure the savable data page’s Data Source is set to Data Transform, not connector
    • If optional actions don’t appear, verify the UI theme is Cosmos

    Final Thoughts

    This tutorial covered:

    • Creating optional actions
    • Designing a form to collect customer information
    • Configuring a savable data page
    • Mapping data using a data transform
    • Saving a new record into a data type
    • Troubleshooting common issues

    I hope this helps you better understand how to manage and save data into Pega data types.
    Check out my blog (linked in the video description) for a more detailed, step-by-step guide.

    Thanks for watching, and see you in the next tutorial!

  • How to Create a New Application in Pega Constellation

    How to Create a New Application in Pega Constellation

    What Is Pega?

    Pega is a low-code platform designed to help organizations build applications that automate business processes, manage workflows, and make intelligent decisions using AI and rules. It’s widely used across industries like banking, insurance, healthcare, and government to increase efficiency and improve customer experiences.

    Creating a New Application in Pega

    To create a new application using Dev Studio, follow these steps:

    1. Start the Application Wizard

    1. Log in to your Pega environment.
    2. Click Application → New Application.

    You’ll be presented with two options:

    • Build from scratch
    • Select an existing application type from Pega’s out-of-the-box (OOTB) offerings

    If you click Search all types, you’ll see a list of available applications. Since the Personal Edition includes fewer preloaded apps, we will proceed with Build from scratch.

    2. Choose the Application UI Architecture

    Pega provides three UI frameworks you can build your app with:

    • Traditional UI
    • Cosmos (modern, flexible, dynamic)
    • Constellation (the latest React-based, component-driven UI model)

    For this example, we’ll select Traditional UI, then click Next.

    3. Name and Create the Application

    Enter a name for your application and proceed to create it.

    You will then be prompted to define:

    • User types
    • Roles

    For now, we will skip this step and click Done.

    4. Why You Don’t See the App Immediately

    After creating the application, you might notice that it doesn’t appear in your Application menu.

    This is expected.

    When Pega creates a new application, it also generates required system assets—one of those is an Access Group. Access Groups determine:

    • Which applications a user can access
    • What permissions and roles they have

    Since your operator ID does not yet include the access group for the new application, you cannot access it.

    5. Assign the Access Group to Your User

    To add access to the new application:

    1. Click your operator name in the lower-left corner.
    2. Select Operator → Application Access.
    3. Search for the Access Group created for your new app.
    4. Add it to your user profile.
    5. Log out and log back in.

    After logging in again, your new application will now appear in the Application menu.

    Your application is ready! From here, you can start configuring case types, data objects, UI components, and more. Let me know if you want a follow-up tutorial on building your first case type or setting up data structures.

  • Pega tutorials-Create an external data source with REST integration in Pega

    Pega tutorials-Create an external data source with REST integration in Pega

    In this tutorial, we’ll walk through how to create an external data source in Pega, configure it using an external REST API, and finally use it to populate a dropdown in a case.

    1. Creating the Data Object

    To begin, go to:

    Data → New

    This opens the wizard for creating a new data object.

    Enter a name for your Data Object, then click Next.

    In the System of Record dropdown, select Create new, and enter a name for the new system of record.

    For this example, we will integrate with an external API that returns a list of countries.

    2. Defining the External Data Source

    Since we are retrieving information, we’ll use a GET method.

    Enter the endpoint URL for the external API.

    In this example, the service does not require headers or authentication, so we can simply click Initialize call to generate the structure.

    3. Selecting the Fields to Source

    The API response includes multiple details—country name, currency, languages, and more.
    You do not need to map all values. Instead, select only the properties you need.

    Click Add new and choose the specific fields that should be included in your data object.

    Environment Settings

    This section displays the Integration System Settings created automatically.
    These help manage different endpoints across development, staging, and production environments.

    4. Reviewing the Generated Data Type

    Open the data type you just created. You will notice:

    • The System of Record is set to External
    • The data source is the Get Countries API

    The wizard also automatically generates a Data Page in Page List mode.
    This Data Page is ready to be used as the source for:

    • Dropdowns
    • Autocomplete fields
    • Any UI component requiring country data

    5. Reviewing the Generated Data Page

    The Data Page is already configured with:

    • The Connector
    • The Response Data Transform

    Since the API does not require parameters, no Request Data Transform is needed.

    Click Run to test the Data Page.
    This confirms:

    • The API connection is successful
    • The response mapping works correctly
    • All returned data is visible under pxResults

    You should now see a list of all countries retrieved from the API.

    6. Using the Data Page in a Dropdown

    Next, let’s use the Data Page as the source for a dropdown field.

    In your case or UI section:

    1. Select Field type: Data Page
    2. Enter the Data Page name created by the wizard
    3. Set the parameter value to countries (or the name used in your Data Page)
    4. For the Property value, select Alpha Code
    5. For the Display text, select Name

    Click Save, and then run a case to verify that the dropdown loads correctly.

    Open the dropdown and choose any country.
    Check the Clipboard to confirm the selected country is saved properly.

    This completes the process of creating and using an external data source in Pega—from configuring the API to integrating it into your UI. If you have any questions or run into issues, feel free to ask!

  • SOAP Integration in Pega from scratch

    SOAP Integration in Pega from scratch

    1. Launching the SOAP Integration Wizard

    In Dev Studio, go to:

    Configure → Integration → Create SOAP Integration

    This opens the SOAP Integration Wizard.

    The first step is to provide a WSDL URL, which defines the structure of the web service.
    For this example, we will use:

    http://www.dneonline.com/calculator.asmx?WSDL

    Click Next to continue.

    2. Reviewing Service Metadata

    After loading the WSDL, the wizard displays:

    • Service name
    • Port name
    • Endpoint
    • Available operations

    You can test operations from this screen. Once testing is done, click Next.

    3. Integration Layer Configuration

    The wizard now shows:

    • The integration class
    • The ruleset
    • The context where the integration assets will be created

    Click Preview Records to see all rules the wizard will generate. This modal displays the rule types and quantities.

    When clicking Create, you may encounter an error. This happens because Pega sometimes does not automatically create the integration class for SOAP services.

    If this occurs, manually create the class where all integration assets will be stored. After creating the class, click Create again.

    This time, the SOAP connector will be successfully generated.

    You’ll see:

    • Class name
    • Ruleset
    • WSDL
    • All created data sources
    • Option to Undo Generation, which removes all generated rules if needed

    Click Close when finished.

    4. Reviewing the Generated Connector

    Navigate to the integration class:

    App Class → Calculator → Integration-Connectors → Connect SOAP

    Here you’ll find one connector rule per operation defined in the WSDL.

    Inside each connector you can verify:

    • Endpoint details
    • Error handling
    • Processing options
    • Simulation settings

    Connector Request & Response

    Under the Request tab, you’ll find:

    • SOAP headers (if any)
    • Request parameters
    • The XML Stream rule (e.g., AddParameters) responsible for request mapping

    The Response tab includes the same structure for mapping outputs.

    5. Creating the Data Page

    Next, create a data class to hold the response from the service.
    Then create a Data Page that will invoke the SOAP connector.

    Configuration:

    • Source type: Connector
    • Connector type: SOAP
    • Connector name: Add (for this example)

    You can try the other operations later as practice—feel free to leave a comment if you have issues.

    6. Request Data Transform

    Create a Request Data Transform that passes two parameters:

    • intA
    • intB

    Make sure these parameters exist both in the Data Page and in the Data Transform.

    Map the two variables to the fields expected by the SOAP service.

    7. Response Data Transform

    Pega automatically generates a boilerplate Response Data Transform, but you can customize it.

    Important note:
    If the connector response returns a page, you must create the corresponding property in your data class and map the values one-to-one.
    If your data page runs successfully but the response appears empty, it’s usually because this mapping step was missed.

    8. Testing the Integration

    To test the integration:

    1. Open the connector rule
    2. Scroll to the bottom
    3. Click Test Connectivity

    If the service fails, Pega will show the error details.

    To test the Data Page:

    1. Open the Data Page
    2. Click Actions → Run
    3. Enter parameters (intA and intB)
    4. Validate the results and response status

    If any errors occur, they will appear in the results panel.

    Summary — Complete Integration Steps

    1. Obtain the WSDL
      Example: http://www.dneonline.com/calculator.asmx?WSDL
    2. Validate required headers or authentication (Postman helps with this).
    3. Go to
      Configure → Integration → Create SOAP Integration
      and follow the wizard.
    4. Verify generated classes and rules.
    5. Test connectivity in the connector.
    6. Create:
      • Data class
      • Data Page
      • Request Data Transform
      • Response Data Transform
      • Any needed properties
    7. Map request and response values.
    8. Run the Data Page and validate that the service works end-to-end.

    You can watch the full step-by-step demonstration in the accompanying video.
    Feel free to leave questions or comments—happy integrating!

  • How to Create a Bank Application Using Pega Blueprint (Step-by-Step Guide)

    How to Create a Bank Application Using Pega Blueprint (Step-by-Step Guide)

    In this tutorial, we’ll walk through how to create a complete pay (KYC onboarding) application using Pega Blueprint, the new automation tool that allows you to generate case types, data models, personas, and application structure with minimal manual setup.

    Blueprint drastically reduces the time required to build an application from scratch, giving you a ready-to-customize foundation aligned with your business needs.

    1. Accessing the Blueprint Dashboard

    To get started, navigate to:

    mega.com/blueprint/dashboard

    Log in with your account, and you’ll see the Blueprint dashboard.
    Click Create Blueprint to begin.

    2. Selecting Templates and Application Context

    Blueprint provides a library of templates according to the industry and type of application you’re building.

    1. Industry: Select Banking
    2. Click Next
    3. Sub-Industry: Choose Retail Banking
    4. Department: Select Onboarding New Customers

    Blueprint will then ask for the application purpose. Choose:

    • Know Your Customer (KYC)

    You’ll also select:

    • Language
    • Location

    Click Next, and Blueprint will start generating your template.

    This process may take a minute. Blueprint analyzes your inputs and builds an initial application with stages, case types, personas, and data objects tailored to your selection.

    3. Choosing Case Types

    Once the generation is complete, you will be prompted to select the case types to include in the application.

    For banking and KYC workflows, common case types include:

    • Global KYC Customer
    • Screening Cases (e-screening, adverse media, etc.)
    • Onboarding Investigation
    • Related Party Onboarding

    Select the case types that apply and click Next.

    Blueprint will display each case type with its stages and processes. For example:

    • Identification & Due Diligence
    • Background Screening
    • Risk Assessment
    • Final Resolution

    4. Selecting the Data Object

    Blueprint will then ask for the primary data object.
    For onboarding workflows, select the basic customer information object.

    Click Next.

    5. Defining Personas

    You can now define the personas who will interact with the application. Example personas include:

    • KYC Analyst
    • Operations Manager
    • Credit Analyst Manager

    Blueprint can auto-generate personas using AI, or you can manually add them.

    Click Next.

    6. Reviewing Your Blueprint

    Blueprint generates a complete application outline, including:

    ✔ Stages and Workflows

    For example:

    • Identify Due Diligence
      • Required customer information
      • Screening and documentation review
    • Perform Due Diligence
      • Background checks
      • Regulatory validations
      • Risk evaluation
    • Resolve
      • Final decision
      • Case closure

    ✔ Data Model

    Blueprint creates:

    • Properties and fields
    • Data objects
    • Embedded objects
    • Child cases

    ✔ Personas and Access Layers

    ✔ Sample Data

    When everything looks correct, download the Blueprint file.

    7. Uploading the Blueprint to Pega

    Go to your Pega environment and create a new application.

    Choose:

    “Build from a Blueprint”

    Upload the file you downloaded earlier.

    Pega will begin generating:

    • Case types
    • Data objects
    • Personas
    • Portals
    • Sample data

    This process may take several minutes. In my example, Blueprint generated:

    • 13 case types
    • 17 data objects
    • 14 personas
    • 3 channels (portals)

    8. Reviewing the Application in Dev Studio

    Once the application is created:

    1. Switch to Dev Studio
    2. Verify that the correct branch is attached
    3. Review:
      • Case types
      • Workflows
      • Data objects
      • Views
      • Background rules

    Sometimes Blueprint may not fully configure all case creation rules, so minor adjustments may be required.

    9. Exploring the Application in App Studio

    App Studio is the best place to work with:

    • Views
    • Data models
    • Relationship maps
    • Case previews

    Use the Data Model Viewer to visualize relationships between data objects.
    Use Case Type Preview to run a test case, review screens, and evaluate user flow.

    In the example:

    • The Global KYC Customer case type has stages automatically created by Blueprint.
    • Some child case creation steps needed manual correction.
    • Views are fully editable in App Studio, replacing old-style section rules.

    10. Editing Views and Data Models

    Constellation uses views instead of sections.

    You can:

    • Add fields
    • Modify layouts
    • Use data transforms
    • Configure validation
    • Reuse views across case types

    If a rule appears locked, check your branch settings.
    Always work with Branch Development ON to prevent version conflicts.

    11. Final Notes and Next Steps

    Blueprint gives you a strong foundation, including:

    • Application structure
    • Case lifecycle
    • Personas
    • Data models
    • Sample logic

    From here, you can:

    • Refine workflows
    • Add missing logic
    • Configure validation
    • Build UI views
    • Define relationships between objects
    • Customize the entire onboarding process

    In upcoming tutorials, we’ll explore:

    • Creating views in Constellation
    • Building and connecting data objects
    • Configuring background logic using calculated expressions
    • Fixing child-case creation flows
    • Mapping end-to-end onboarding processes

    If you have questions, leave them in the comments — I’m happy to help.