Pega Underwriting for Insurance

Transcription

1 Pega Underwriting for Insurance 7.13 IMPLEMENTATION GUIDE

2 Copyright 2015 Pegasystems Inc., Cambridge, MA All rights reserved. This document describes products and services of Pegasystems Inc. It may contain trade secrets and proprietary information. The document and product are protected by copyright and distributed under licenses restricting their use, copying, distribution, or transmittal in any form without prior written authorization of Pegasystems Inc. This document is current as of the date of publication only. Changes in the document may be made from time to time at the discretion of Pegasystems. This document remains the property of Pegasystems and must be returned to it upon request. This document does not imply any commitment to offer or deliver the products or services provided. This document may include references to Pegasystems product features that have not been licensed by your company. If you have questions about whether a particular capability is included in your installation, please consult your Pegasystems service consultant. PegaRULES, Process Commander, SmartBPM and the Pegasystems logo are trademarks or registered trademarks of Pegasystems Inc. All other product names, logos and symbols may be registered trademarks of their respective owners. Although Pegasystems Inc. strives for accuracy in its publications, any publication may contain inaccuracies or typographical errors. This document or Help System could contain technical inaccuracies or typographical errors. Changes are periodically added to the information herein. Pegasystems Inc. may make improvements and/or changes in the information described herein at any time. This document is the property of: Pegasystems Inc. 1 Rogers Street Cambridge, MA Phone: (617) Fax: (617) Document: Pega Underwriting for Insurance Implementation Guide Software Version: 7.13 Updated: January 2015

3 CONTENTS About this Document... i Intended Audience... i Guide Organization... i Overview Highlights Architecture What is already Setup Application rules Pega Underwriting for Insurance Personal Lines Individual Life and Annuity Implementation: Work Classes Data Classes: An Overview Prefixes Work Groups and Work Baskets Operators, Access Groups and Portals Using Case Management Work parties Data tables Sample Data PUI Specific Pega App Data Model Database Tables Data Classes - Details Interface Classes Using PUI PUI Cases Duplicate Search Routing Correspondence Proposal Data Pages D_Customer Data Page D_BusinessUnitList Data Page

4 D_AddressList Data Page D_CommunicationOptionsList Data Page D_ContactList Data Page User Experience Application Skin HTML5 Application Readiness Dynamic Layouts UI Inspector PUI Deep Dive Submission and Application Submission - General and Specific Flows Submission and Application-- Personal Lines Quote Data classes in Quotes Configuring Quotes Product Variances Quotes Clipboard Structure: Coverage List Survey Survey Structure Creating and Managing Surveys in PUI Managing a Customer Account (MCA) Accessing the MCA work object for a Customer MCA Technical Configuration Creating MCA from Submission Process Agency and Agent Management (AAM) Landing Page Agent Search and Configuration Agency Search and Configuration Create Agent and Agency Configuration Configuring Products: Using Product Builder Core Extending PUI Running the New Application Wizard Extending an Existing LOB Creating a New LOB Data Tables... A-1

5 About this Document Intended Audience This guide is intended for those individuals who are implementing and extending Pega Underwriting for Insurance (PUI). Guide Organization This guide contains the following sections: Chapter 1: Introduction Chapter 2: Framework Architecture Chapter 3: Using the Framework Chapter 4: PUI Deep Dive Chapter 5: Extending the Framework Provides an overview of PUI. Outlines the architecture of PUI. Describes how to use PUI. Describes detailed technical configuration and functionalities. Describes how to extend PUI. Pega Underwriting for Insurance Implementation Guide i

6 1 Overview Pega Underwriting for Insurance (PUI) is powered by Pega 7 ease-of-use and improved developer experience to support reduced time to market and enable a quicker response to customer needs. The Pega 7 enhanced development features promote enterprise-wide collaboration and coordination. A new look and feel, paired with improved performance, enhances both the developer and end-user experience. Pega 7 brings straight-forward case management design, flexible data reuse, security, mobile and social capabilities, and connectivity enhancements to your applications to drive customer satisfaction. PUI uses the Pega 7 stage-based case management features that automate many of the manual processes involved in the submission process and increases visibility of the case status across the new business value chain. PUI reduces submission, multi quote, and policy issuance processing times, increases productivity, and enables an improved customer and producer experience. Using the Pega BPM technology enables insurers to Build for Change by providing the agility to customize submission processes to satisfy the needs of different distribution channel partners and market opportunities, improve new business submission and application processing turnaround times, and reduce operating expenses. Insurers can rapidly build and deploy new business processes that automate work steps and adapt to changing business needs and market conditions. Furthermore, insurers can reuse these processes across lines of business and reduce submission cycle times across their operations. Highlights PUI enables you to implement solutions that provide: End-to-end, stage-based case management that manages all account tasks for comprehensive visibility, as well as tracking and processing consistency across channels. An easy way for business people to use Pega 7 Case Designer to capture objectives in a single view that all parties from application designers to executives to end users can examine to understand how a particular case type works and progresses. Comprehensive case management that supports work strata, content, and document management throughout every step of a process. Quick integration with systems of record that automates onboarding, including built-in verification rules that ensure complete and accurate information. Reusable user assets from the Insurance Industry Framework (IIF) that provide an extensive library of insurance components, common objects, and data models based on the standard Insurance Application Architecture (IAA). Pega Underwriting for Insurance Implementation Guide 1-1

7 Guided processes that help Underwriting staff drive work to completion and eliminate manual handoffs using routing that assigns work to the right resource at the right time. Intelligent processes that qualify a multi-line submission as a single request, and that reduce submission time and eliminate redundant data entry with a complete audit trail that tracks user and system-generated activities for tighter control. Pega Underwriting for Insurance Implementation Guide 1-2

8 2 Architecture What is already Setup Application rules Application rules define an ordered set of rulesets and versions that together identify the parts of an application. In addition, application rules relate an application's objectives, use cases, requirements, and actors to cases that are created as part of the Pega 7 Direct Capture of Objectives capabilities. You can view a list of the PUI application rules and their rulesets from the Designer Studio by selecting the DesignerStudio > Application > Structure > Rule Set Stack landing page option. The Rule Set Stack tab displays the high level ruleset stack for each application rule defined in PUI. Expand an application to list its rulesets. To see the ruleset stack for any of the supporting application layers, click the Expand button (+) next to the application to expand and display the list. Pega Underwriting for Insurance The application name and version for PUI is PegaInsuranceNBB:7.13. This is the basis for market segment specific applications for Property and Casualty (P&C) Commercial Lines, P&C Personal Lines, Group Benefits, and Individual Life and Annuity. The Personal Lines, Individual Life and Annuity, Group Benefits, and Commercial Lines are split into different applications that are built on PegaInsureNBB:07:13. PegaInsuranceNBB is built on PegaInsurance 7.15 which represents the IIF layer (Insurance Industry Foundation) that is built on PegaRULES Pega Underwriting for Insurance Implementation Guide 2-1

9 The following figure shows the PegaInsuranceNBB Application rule: Pega Underwriting for Insurance Implementation Guide 2-2

10 The following figure shows the standard application ruleset stack for operators packaged as part of PUI: Pega Underwriting for Insurance Implementation Guide 2-3

11 Rulesets The PegaInsuranceNBB application consists of a single ruleset named PegaInsureNBB that holds all PUI specific rules. The PegaInsurance application consists of the following rulesets: PegaInsure Core IIF rules PegaIns-Product Core rules for Product Builder for Insurance (PBI), which is a separate application bundled with PUI. PBI helps to define insurance policies along with risks, coverages, and so on. PegaSurvey Separate application bundled with PUI to define surveys and questionnaires. PegaApp Basic data models related to contacts, business units, and so on. Piif Classes and rules that support IAA data model PegaSP Product Configurator (PCF) rules which can be used to define an insurance policy. As of this release, we include this only for backward compatibility. Currently no PUI flow refers to products created using PCF. PegaInsureUI UI-specific rules for IIF such as images, harnesses, portals, and skins. UI-Kit UI-related rules such as skins, CSS files, and images, which are compatible with Pega and Pega PegaFWUI UI-related rules such as skins, CSS files, and images, which help achieve a standard look and feel across the Pega platform. Personal Lines The application name and version for the PUI Personal Lines (PUI PL) framework is PegaInsurancePAPL: The PegaInsurancePAPLVerify:07.13 application is built on the PegaInsurancePAPL:07.13 application, which is built on the PegaInsuranceNBB:07.13 application, which is built on the PegaInsurance:07.15 application. PegaInsuranceNBB:07.13 represents the PUI layer (Pega Underwriting for Insurance) and IIF represents the foundation layer (Insurance Industry Foundation), which is in turn built on the PegaRULES application. Pega Underwriting for Insurance Implementation Guide 2-4

12 The following figure shows the PegaInsurePAPLVerify:07.13 application rule: Pega Underwriting for Insurance Implementation Guide 2-5

13 The following figure shows the application ruleset stack: Rulesets The PegaInsurePAPLVerify:07.13 application consists of rulesets named PegaInsurePAPLVerify and PLSampleProducts that hold all PUI PL Verification specific rules and Personal Line sample products respectively. PegaInsurePAPL:07.13 application consists of rulesets named PegaInsurePAPL and PegaInsurePAPC that hold all PUI PL specific rules. PUI PL System Administrator accounts A full list of users installed with the framework can be found in the Demo End User Accounts topic on page Use the following administrator ID to access and work with the framework rules and processes: User ID: PLVerificationSysAdmin Password: install Pega Underwriting for Insurance Implementation Guide 2-6

14 Individual Life and Annuity Implementation: The application name and version for the PUI Individual Life and Annuity (PUI LA) framework is PegaInsuranceILAVerify: The PegaInsuranceILAVerify:07.13 application is built on the PegaInsuranceILA:07.13 application, which is built on the PegaInsuranceNBB:07.13 and PegaInsurance:07.15 applications, which represent the PUI (Pega Underwriting for Insurance) and IIF (Insurance Industry Foundation) layers, which are in turn built on the PegaRULES application. The following figure shows the PegaInsureILAVerify:07.13 Application rule: Pega Underwriting for Insurance Implementation Guide 2-7

15 The following figure shows the Application ruleset stack: Rulesets The PegaInsureILAVerify:07.13 application consists of rulesets named PegaInsureILAVerify and ILASampleProducts that hold all PUI ILA Verification specific rules and Individual Life and Annuity sample products respectively. The PegaInsureILA:07.13 application consists of rulesets named PegaInsureILA and PegaInsurePAPC that hold all PUI ILA specific rules. PUI ILA System Administrator accounts A full list of users installed with the framework can be found in the Demo End User Accounts topic on page Use the following administrator ID to access and work with the framework rules and processes: User ID: ILAVerificationSysAdmin Password: install For a Commercial Line implementation, see the PUI CL 7.13 Implementation Guide. Pega Underwriting for Insurance Implementation Guide 2-8

16 For a Group Benefits implementation, see the PUI GUW 7.13 Implementation Guide. Work Classes Work classes support the behavior and appearance of the work items created and processed in PUI. Every work class in PUI maps to a table named IIF_WORK in the PegaData database. Most work classes in PUI have a pattern inheritance to the abstract class PegaIns-PAB-Workand hence this class can be called as the top level work class in PUI. It directly inherits from PegaIns-Work-Cover- and has a pattern inheritance from PegaIns-PAB-. Classes and Work Types PUI has multiple class groups, the most important of them being the PegaIns-PAB-Work- Submission class. All the submission work types in PUI are created as child classes within this class group. The list of the submission work classes is shown below. Work Class PegaIns-PAB-Work-Submission-Pers-Auto PegaIns-PAB-Work-Submission-Pers- Umbrella PegaIns-PAB-Work-Submission-Life PegaIns-PAB-Work-Submission-Com-GL PegaIns-PAB-Work-Submission-Com- Property PegaIns-PAB-Work-Submission-Package- Pers PegaIns-PAB-Work-Submission-Package- Com PegaIns-PAB-Work-Submission-Pers- Watercraft Work Type Personal Auto Submission Personal Umbrella Submission Life Submission Commercial GL Submission Commercial Property Submission Personal Bundle Submission Commercial Package Submission A sample submission to be used as a reference for extending PUI to include a new LOB The PUI work types other than submission appear below: Work Class Work Type Class Group PegaIns-PAB-Work-LossControl Loss Control Survey PegaIns-PAB-Work- LossControl PegaIns-PAB-Work-PolicyService- Loan-Life Policy Loan PegaIns-PAB-Work- PolicyService PegaIns-Work- ManageCustomerAccount Customer Account PegaIns-Work In earlier versions, PUI included Application work types belonging to the class group PegaIns- Work-Application. Starting in release of 7.11, all the work types have been consolidated into the submission class group. Because some rules are available in the application class group from previous releases, you will notice that direct inheritance of some work types such as Pega Underwriting for Insurance Implementation Guide 2-9

17 Commercial GL point to these application classes to make use of existing rules. For example, PegaIns-PAB-Work-Submission-Com-GL has a direct inheritance to PegaIns-PAB-Work- Application-Com-GL. PUI PL and PUI ILA are bifurcated into different layers from this release and the work class and work types are listed below for reference. Work Class PegaIns-PAB-PC-PL-Work-Submission-Vehicle-Auto PegaIns-PAB-PC-PL-Work-Submission-Vehicle PegaIns-PAB-ILA-Work-Submission PegaIns-PAB-PC-PL-Work-Package Work Type Personal Auto Submission Personal Umbrella Submission Life Submission Personal Bundle Submission Data Classes: An Overview Data classes support capture and data storage for the processing of submission cases. To display the data class structure: select the class from the explorer panel, right-click, and then select Inheritance. Data classes can be added to the PegaInsuranceNBB Application rule in the Cases and Data tab. Data types defined here appear in the Data Explorer. This tab also provides a single view of all the data classes defined and used for the current application and built-on application. The following figure shows the Data class structure: Pega Underwriting for Insurance Implementation Guide 2-10

18 The following table lists the key data classes: Data Class Description Directly Inherits from PegaIns-Data-Application Contains data pertaining to the application for a specific PegaIns-Data LOB PegaIns-Data-InsurancePolicy Represents a general insurance policy. It is specialized Piif-InsurancePolicy by its LOB specific subclasses. PegaIns-Data-Customer Contains data pertaining to the applicant Piif-Customer PegaIns-Data-Quote Pertains data pertaining to the quotes associated with PegaIns-Data the Application PegaIns-Data- Submission Contains data pertaining to a submission PegaIns-Data PegaIns-Data-SICCode Contains data pertaining to the SIC code derived for the PegaIns-Data Business Customer (applicant) PegaIns-Data-PolCmp- Contains data pertaining to the policy components for all Data- LOBs PegaIns-Data-PremiumBilling Contains data pertaining to the billing-related PegaIns-Data information PegaIns-Data-Line Contains LOB related details PegaIns-Data PegaIns-Data-DiscountCode Contains discount codes used in commercial PegaIns-Data submission PegaIns-Data-HazardCodes Contains hazard codes used in commercial submission PegaIns-Data PegaIns-Data-SurchargeCode Contains surcharge codes used in commercial submission pricing. PegaIns-Data Data Model The Data Model landing page, shown below and accessible from the DesignerStudio menu, provides a 360 degree view of the application and built on application data. Pega Underwriting for Insurance Implementation Guide 2-11

19 It provides details about classes and properties, data tables used in the application, class relationships, database class mappings, and more. Properties The Property Tree tab displays all properties available for use in an application or built on application in a tree grid. For example, for the PegaIns-PAB-Work-Submission Applies To class, the tab displays the properties shown in the figure below. You can select filter criteria to filter the resulting list. For embedded properties, click the Expand button (+). Click a property to open its rule form. See the Application Developer Help for more information. The Class Relationships tab shows the relationships between the application's properties that have a Page mode (Page, Page List, Page Group) and their page classes. These classes are also known as embedded classes, and the properties are known as embedded properties. The tab also shows which ruleset the page mode property belongs to. Pega Underwriting for Insurance Implementation Guide 2-12

20 For example, the following are the page mode properties filtered for the Applies To class PegaIns-PAB-Work-Submission: Database Class Mappings The Database Class Mappings tab displays all current database mappings for the selected class category. This information is derived from the Data-Admin-DB-Table data instances and queries to the PegaRULES database. Pega Underwriting for Insurance Implementation Guide 2-13

21 Based on the category selected (see the previous figure), the tab displays the following information for each class it finds: database and relational database table in the database that class is mapped to, number of columns in the table, and number of columns exposed to the interface. For example, the following figure shows the IIF Work classes and their mappings. Pega Underwriting for Insurance Implementation Guide 2-14

22 The following figure shows some of the Data classes in IIF: The following figure shows the sample data and its table mapping: Pega Underwriting for Insurance Implementation Guide 2-15

23 Sample Database Model IIF uses a database table named IIF_Work in the PegaDATA database to store case data. To view the database table and its properties: 1. You can view a list of the database tables in IIF from the Designer Studio by selecting the DesignerStudio > System > Database > Modify Schema landing page option. 2. Select the PegaRULES database and click Next. Pega Underwriting for Insurance Implementation Guide 2-16

24 3. Select a table from the list and click Next to display the List of Classes in the table. 4. Since PUI is built on top of IIF, select IIF_Work table. Pega Underwriting for Insurance Implementation Guide 2-17

25 5. View the columns and properties. In the fields above the List of Classes table, click the number link to the right of the Columns in this table field (e.g., 97 in the example shown above) to view a table of database columns along with their data type and size 6. In the List of Classes table (see figure earlier in this procedure), click the number in the Properties, Set to be visible column to display a detailed table of the database properties. te: When you implement external interfaces, your interface activities should map your data back to this work table. As part of you deployment, it is recommended that you work with your database administrator to customize and tune the database tables for optimal performance. Pega Underwriting for Insurance Implementation Guide 2-18

26 Prefixes PUI creates a Customer Account (CA) cover object and associated submission covered work objects. Each has a unique ID that is computed by combining a system-assigned number and a prefix defined in the Cases and Data tab of the PegaInsuranceNBB Application rule. This table lists the prefixes for the work objects and their associated work class: WorkObject Description Applies to this Class Prefix SUB- Submission work object prefix for all monoline submissions Respective LOB specific classes under: PegaIns-PAB-Work-Submission PB- Submission work object prefix for personal PegaIns-PAB-Work-Submission-Package-Pers bundle submission CA- Customer Account information pertaining to the Customer PegaIns-Work ManageCustomerAccount PL- Policy loan work id prefix PegaIns-PAB-Work-PolicyService-Loan-Life These work object prefixes are defined in the Cases and Data tab of the PegaInsuranceNBB Application rule. These can be copied over to your application rule and changed as per your requirement. The following diagram shows the Cases and Data tab of the Application rule where the work object prefixes are defined. A prefix entered here overrides a prefix specified in the pydefault data transform. Leave the prefix setting blank here to use the data transform setting. Pega Underwriting for Insurance Implementation Guide 2-19

27 Work Groups and Work Baskets Users are given access to particular workbaskets for processing work. The work group of the user determines which workbaskets they can access. Select DesignerStudio > Org & Security > Tools > Work Groups landing page option to display a list of work groups and their associated workbaskets. Select the DesignerStudio > Org & Security > Tools > Work Baskets landing page option to display a list of workbaskets and their associated work groups. The following table lists the main work groups and workbaskets installed with PUI: Work Basket Binders ManageCustomerAccount PartialApplications PendingApplication deferred@pega.com Work Group Default Default InscoUnderwriting Default Default When a package submission is being submitted, the subcases get underwritten independently. Once the underwriting is done, bind and issue needs to happen at the package level. Until the bind happens, the subcases are placed in the deferred@pega.com workbasket. For a newly created contact or business unit, an MCA (Maintain Customer Account) work object gets created and associated. This is a long running work object that tracks all the activities of that customer. This work object is routed to the ManageCustomerAccount workbasket upon creation. Operators, Access Groups and Portals System Administrator Accounts A full list of users installed with PUI can be found in the Demo End User Accounts topic on page 2-21 Use this administrator ID to access and work with PUI rules and processes: User Name Password PABSysAdmin Install This operator uses the access group PegaInsureNBB72:Administrators that is linked to the application PegaInsuranceNBB Pega Underwriting for Insurance Implementation Guide 2-20

28 Demo End User Accounts PUI is installed with a sample set of operators, access groups, and user portals. The password for the sample operators is install. The sample operators allow you to access the Designer Studio to view and configure the underlying processes and rules, and to launch business processes from a variety of user roles including managers and users. Select the DesignerStudio > Org & Security> Organization > Operators landing page option to display a list of operators. Select the DesignerStudio > Org & Security > Security landing page option to display a list of access groups and access roles. This table lists the shipped operators, access groups, and their associated portal rules (i.e., the default portal). Operator ID Access Group Default Portal PABSysAdmin PegaInsureNBB73:Administrators Developer pabuser PegaInsureNBB71:User pycasemanager7 Access Groups The access groups shipped with PUI include: Access Group Name PegaInsureNBB73:Administrators PegaInsureNBB71:User Purpose NBB System Administrators NBB Users Portals PUI ships with two default portals: Case Manager 7 User Portal Pega Underwriting for Insurance Implementation Guide 2-21

29 Using Case Management PUI is configured using the Pega 7 case management features to define how work is processed. This set of capabilities allows you to: Construct covering relationships and build new case types using a tree structure. Add a new case type, which automatically creates Class and Case Type rules. A new case type includes standard starting flows. Re-use existing case and work types Manage various aspects of work processing, including: Service levels. Attachments categories and automatic attachments. Automatic and conditional instantiation of covered items. Mapping roles to object access for your various cases and work types. Case Management features are accessed from the Designer Studio by clicking Cases on the Explorer panel at the left side of the Designer Studio. Configuration Tip: For complete information about using case management features and functions, see the articles in the Case Management section of the PDN and the online Application Developer help. For example, the commercial Package process has various types of supporting processes and covered Work Types. These are defined in a case type rule called pydefault (see the figures below), which is in the PegaIns-PAB-Work-Submission-Package-Com class. Invoking of these submissions can be done from the specific implementation layers. For example, Life Submission can be invoked from the Individual Life and Annuity Implementation layer, and Commercial and Personal Lines Submissions can be invoked from the Commercial Lines Implementation layer and Personal Lines Implementation layer respectively. Pega Underwriting for Insurance Implementation Guide 2-22

30 Pega Underwriting for Insurance Implementation Guide 2-23

31 When a commercial package work object is created, all of these coverable work types can be seen in the case manager portal as shown below. Select the work types you want to include and click the Submit button. This image demonstrates the look and feel of these stages on a UI in PUI. The work type name displays next to the Commercial Package Submission. Pega Underwriting for Insurance Implementation Guide 2-24

32 Defining Stages Define all possible stages in the case type rule and add steps to each stage. Each step within a stage will have a corresponding flow rule. Work parties Work party rules define which participants (roles) can be associated with a work object. Each work object can contain many roles in addition to the required Originator role. Some roles may participate with multiple occurrences. The work party rule also controls how and whether users can add parties from the user forms. The preconfigured processes support the following work parties: Originator Applicant Underwriter Pega Underwriting for Insurance Implementation Guide 2-25

33 Policyholder Agent Agency For example, when the policy is issued for a Commercial GL submission, the following work parties are generated at the appropriate process steps in the submission process: There can be additional work parties who are not in the insurance contract such as brokers, third party vendors, and so on. These work parties are defined in the Default rule under the Process > Work Parties category in the appropriate work class. Pega Underwriting for Insurance Implementation Guide 2-26

34 The following figure shows an example of work parties are defined in the Default work parties rule for a commercial submission: These work parties can be modified or additional parties can be defined as per the site specific implementation requirements. Pega Underwriting for Insurance Implementation Guide 2-27

35 Example of Agency/Agent work party creation In the submission process, after the agency and agent are linked to the process, their respective work parties are created and attached to the submission. The activity PegaIns-PAB-Work-Submission addagencyandagentparties creates these parties. We make use of the out of the box activity addworkobjectparty for work party creation. This activity requires a data transform to set the required properties to the party. For an agent, the MapAgentPartyDetails data transform is defined in the Default work party rule for this purpose as shown above in the Default work party rule figure. Similarly, an agency work party is created by this same activity. At the appropriate stages in the submission process, other work parties are also created. The following is the clipboard structure of work parties created for a commercial GL submission: Pega Underwriting for Insurance Implementation Guide 2-28

36 When persisting the issued policy to the data base, work parties are saved as PartiesToAgreement in PegaIns-Interface-InsurancePolicy as shown below. In a Commercial submission, the Underwriter work party is created by the activity PegaIns-PAB- Work-Submission SetUnderwriterPartyDetails, which is invoked from the flow PegaIns-PAB- Work-Submission-Com ExecuteUnderwriting. Pega Underwriting for Insurance Implementation Guide 2-29

37 Data tables The Data Tables landing page contains the Data Tables tab. Use the Data Tables tab to identify the data tables in the application, create new data tables in the application, and list, insert, delete, or update rows in a data table. A data table is a simple structure consisting of the rows of a Pega 7 concrete class that contain only scalar (Single Value) properties. Informally, a data table is the Pega 7 internal representation of a flat file that contains no repeating groups. The Data Table editor allows for easy entry and maintenance of data instances for classes that have a simple structure. Two important points to remember while creating data tables: Data tables should be derived from the Data-base class Data tables should contain properties of mode Single Value or Value List te: Do not attempt to create a Data Table class derived from the Work- base class. Work objects are not designed to define reference data, although they may contain properties that have values from Data Tables. Instances of data classes created through the data table wizard are stored in the PegaRULES database table named pr_other unless the Create Dedicated Database Table check box is selected. The following figure shows the Data Tables landing page: Pega Underwriting for Insurance Implementation Guide 2-30

38 The following figure shows some of the data tables that are used in PUI: These tables can be modified by using the search and edit icon as shown below: Pega Underwriting for Insurance Implementation Guide 2-31

39 For example, the following figure shows the Vehicle Make data table open for editing: Tip! When creating a data table, it is advisable to use a dedicated table if your data table might eventually contain many rows (i.e., hundreds), have high turnover, or be moved to other Pega 7 systems. Sample Data PUI ships with some sample data such a contacts, business units, and so on, that you can use to test different types of submissions. This data is loaded during the install into the sample database tables. The following tables list the sample data provided. Sample Contacts Name Address id Natalie Song 1000 Washington St. nsong@test.com Boston, MA Pega Underwriting for Insurance Implementation Guide 2-32

40 Name Address id Wade Jones 100 Long Hill Dr. Stamford, CT Sample Business Units Name Address Phone Number Buten Bearings 246 McAllister St Chunky s Cheeseburgers Boston, MA Rogers St. Cambridge, MA Sample Agency Name Address Phone Number A1 Insurance Agency 101 Main St Cambridge, MA Sample Agent Name Address id Ashley Jones 101 Main St. ajones@a1insurance.com Carl Johnson Cambridge, MA Main St. Cambridge, MA cjohnson@a1insurance.com Sample Policies Policy ID Policy Type Policyholder PA Personal Auto Natalie Song PA Personal Auto Wade Jones CP Commercial Property Buten Bearings GL General Liability Buten Bearings LF Term Life Natalie Song FWWSAMP Workers Comp Buten Bearings FWWSAMP Commercial BOP Buten Bearings FWWSAMP Commercial Auto Buten Bearings Pega Underwriting for Insurance Implementation Guide 2-33

41 Policy ID Policy Type Policyholder FWWSAMP Homeowner Natalie Song GL General Liability Chunky s Cheeseburgers CP Commercial Property Chunky s Cheeseburgers The sample data is stored in the following PUI tables: Table Name IIF_POLICY IIF_POLICY_LINK PA_CONTACT PA_ADDRESS PA_COMMUNICATION_OPTIONS IIF_AGENCY IIF_AGENT Purpose Primary table that stores insurance policy information Stores relationships between insurance policies, contacts, and the roles the contacts have in the policy Primary table that stores information about contacts Stores address information about contacts and business units Stores communication information about contacts and business units Stores information about agencies Stores information about agents The reference data that is mandatory for PUI to function is stored in the following tables: Table Name PA_ROLES PA_COMUNICATION_TYPES IIF_VEHICLES PA_ADDRESS_TYPE PA_INDUSTRY IIF_SICDIVISION IIF_SICGROUP IIF_SICTONAICS IIF_SICFACTOR Purpose Stores role information for policy Reference table that stores codes for various communication types like Phone, Fax, etc. Stores data about vehicles, their makes and models required to process personal auto submission Reference table that stores codes for address types like Shipping Address, Home address etc. Reference table that stores different industry types needed to create a new business unit Stores information on SIC Divisions required for commercial submissions Stores information on SIC groups required for commercial submissions Maintains the relation between SIC codes and NAICS codes. Required for commercial submissions Stores information on SIC factors required for commercial submissions Pega Underwriting for Insurance Implementation Guide 2-34

42 PUI Specific Pega App Data Model PUI relies on a horizontal framework named PegaApp for its data model so that it can take advantage of external database tables and the rules to support them. PegaApp defines various classes and properties that are reused by PUI. These values are mostly related to the various parties involved in a policy. The top level class is named PegaApp-. PUI uses the same data model provided by PegaApp to store contacts, business units, their addresses and communication options. Many interface classes in PUI and IIF inherit from the PegaApp classes. For more details, see Interface Classes on page With the introduction of data pages in Pega 7, IIF has its own set of data pages and activities to retrieve and save contacts, business units, and more, thereby greatly reducing the dependency on the PegaApp layer. Database Tables PUI comes with a robust set of industry standard sample data and database tables that simulate the processing environment. You can use these sample database tables as a starting point for integration or for demonstrating the system environment. The following is a brief list of the database tables that are installed with PUI: Database Table Name PA_ADDRESS PA_ADDRESS_TYPE PA_BUSINESSUNIT PA_BUSINESSUNIT_LINK PA_COMMUNICATION_OPTIONS PA_COMMUNICATION_TYPES PA_CONTACT PA_CONTACT_BUSINESSUNIT_LINK PA_CUSTOMER_TYPE PA_INDUSTRY PA_NOTES PA_PRODUCT PA_PRODUCT_TYPE Purpose Stores address information Stores valid address types like home, billing, and so on Stores information about business customers Stores business-to-business relationships Stores communication information for contacts and businesses Stores the valid communication types (for example, HOME- or HOME-PHONE Sample table that stores information about contacts Stores contact-to-business relationships Stores the information used to describe the business unit as a particular type of customer (e.g., Fortune 500, Small Business, Partnership) Stores information that describes the industry in which a business operates Stores ad-hoc notes that are added to contact or policy records Stores product information Stores information about the product type Pega Underwriting for Insurance Implementation Guide 2-35

43 Database Table Name PA_ROLES IIF_AGENCY IIF_AGENT IIF_SCIDIVISION IIF_SCIFACTOR IIF_SICGROUP IIF_SICTONAICS IIF_VEHICLES Purpose Stores roles for policy, contact, and business unit links Stores agency information for all LOBs Stores agent information (agent ID, name, agency code) for all LOBs Stores SIC information for all kinds of business divisions Stores SIC information for all kinds of industry codes Stores SIC information for all kinds of industry Stores NAICs codes for all SIC codes and corresponding descriptions Stores vehicle make, model,and year of manufacture information Each database table includes the following information: Description of the database List of Columns with data type and size Constraints Large object (LOB) storage attributes Foreign key references not defined in the database Referencing tables and columns te: In Oracle, all table data and column headings appear in uppercase characters. In SQL, all table data and column headings appear in lowercase characters. IIF follows a universal approach and uses lowercase characters. te: A complete list of Data Tables with the above details is provided in the Appendix of this guide. Pega Underwriting for Insurance Implementation Guide 2-36

44 Data Classes - Details Important Data Classes Data classes define the data structures for supporting information that PUI uses to process work. This table lists the data classes and information that those classes represent: Data Representing Agency line of business Application data for lines of business Class PegaIns-Data-AgencyLOB PegaIns-Data-Application-Comm-Property PegaIns-Data-Application-Comm-GL PegaIns-Data-Application-Life PegaIns-Data-Application-Pers-Auto Policy types PegaIns-Data-Application-Pers-Umbrella PegaIns-Data-InsurancePolicy-Commercial-GL PegaIns-Data-InsurancePolicy-Commercial-Property PegaIns-Data-InsurancePolicy-Life PegaIns-Data-InsurancePolicy-Personal-Automotive Submission data for lines of business PegaIns-Data-InsurancePolicy-Personal-Umbrella PegaIns-Data-Submission-Com PegaIns-Data-Submission-Life PegaIns-Data-Submission-Pers-Auto Definition of policy components Customer data for insurance work types Underwriting data for lines of business PegaIns-Data-Submission-Pers-Umbrella PegaIns-Data-PolCmp PegaIns-Data-Customer PegaIns-Data-Underwriting-Life PegaIns-Data-Underwriting-Pers-Auto Parties involved in an insurance agreement PegaIns-Data-Underwriting-Pers-Umbrella PegaIns-Data-Party-Person PegaIns-Data-Party-Person-Agent Pega Underwriting for Insurance Implementation Guide 2-37

45 Data Representing Class PegaIns-Data-Party-Operator PegaIns-Data-Party-Org-Company Quotes Hazard codes by SIC/SIC Code PegaIns-Data-Party-Org-Agency PegaIns-Data-Quote PegaIns-Data-HazardCodes PegaIns-Data-SICCode PegaIns-Data-SICDivision PegaIns-Data-SICFactor PegaIns-Data-SICGroup Inheriting from the PegaIns-Data-Structure The PegaIns-Data- class structure (sub classes under PegaIns-Data- point to a Piif class to get maximum reusability) is set up to inherit from the Piif class structure to provide access to the many properties provided in the Piif layer. The Piif class and its children provide the foundation data structures of PUI. It contains over 550 classes, and over 2,000 properties that can be used to represent the data aspects of insurance products, agreements, and life-cycle processing. The structure is based on the Interface Design Model of the IBM Insurance Application Architecture (IAA) version 2006TR with one exception PUI also leverages the extensive Pega 7 party classes and associated rules. Pega 7 party classes are sub classed, with each new class directly inheriting from their Piif equivalent. This provides direct access to both Pega 7 and Piif party properties. As you customize PUI to meet the needs of your own environment, you can leverage the Piif class by having your data classes directly inherit from the corresponding Piif class and then making customizations as necessary to meet your business needs. The structure also can inherit from the PegaIns-Data-PolCmp classes. These classes provide many of the common elements required to create products and their associated policies. They typically aggregate multiple Piif classes to provide more generic objects than using Piif alone. Pega Underwriting for Insurance Implementation Guide 2-38

46 The PegaIns-Data- class structure provides data classes for the following: Data Representing PegaIns-Data-InsurancePolicy PegaIns-Data-PolCmp PegaIns-Data-Party PegaIns-Data-Submission PegaIns-Data-Application PegaIns-Data-Quote PegaIns-Data-Customer PegaIns-Data-PriorCarrier PegaIns-Data-PriorClaim PegaIns-Data-VehicleInfo PegaIns-Data-AgencyLOB Class Represents a general insurance policy. It is specialized by its subclasses that represent lines of business and product groups similar to the class structure in PegaIns-PAB-Work-. Contains a number of subclasses that represent components in a product. These classes are used when defining product and component rules in PBI. Subclasses defined here inherit from the Piif class structure to take advantage of the many Insurance properties provided by IAA IBM s Insurance Application Architecture. Contains classes that define parties. Represents a general submission data work object. It is specialized for various LOB-specific submission data. Represents a general application data work object specialized by its line of business. Represents the estimated premium amount for an applicant based on several factors including the type of insurance, coverage amount, length of coverage, age, gender, health and medical history, family history, build, and approximate rating class. Then, the selected quote is proposed for policy issuance. Represents the customer information, either individual or business. Includes information such as address, communication options, and personal information. Captures the previous carrier insurer information such as policy number, previous effective and expiry dates, and so on. Captures the previous claims filed with carriers. Captures vehicle information such as make, model, annual mileage, and vehicle use. Contains the list of LOBs that an agency is licensed to sell in a given jurisdiction. Pega Underwriting for Insurance Implementation Guide 2-39

47 The following figure shows an example of inheritance from the PegaIns-Data-InsurancePolicy class: The following figure shows an example of inheritance from the PegaIns-Data-Submission-Pers- Auto class: All the data classes that we want to display under the Data Explorer are defined in the Cases and Data tab of the PegaInsureNBB Application rule. Here we can add or delete the data types Pega Underwriting for Insurance Implementation Guide 2-40

48 as needed based on our application and built-on-application relevance and requirement. This also gives us a snapshot of all the data types that we currently use in the application. Pega Underwriting for Insurance Implementation Guide 2-41

49 Interface Classes The PegaIns-Interface- classes contains classes that are used to build interfaces and APIs to external systems. You can extend these classes to leverage the existing configuration to facilitate data access to your core external and backend systems. The interface classes described below are included in PUI. They are concrete data classes used to persist and retrieve insurance policy data. PegaIns-Interface-InsurancePolicy This class inherits from PegaApp-Interface-. PegaApp does not have an InsurancePolicy class to inherit from. Consideration was given to inherit from the PegaApp s Account class, but an account and insurance policy have enough differences to warrant two different classes. The InsurancePolicy class does not inherit from Account. This allows for the expansion of IIF to use the PegaApp-Interface-Account class in the future. PegaIns-Interface-PolicyLink This class inherits from PegaApp-Interface. Similar to the Policy class, PegaApp does not have a PolicyLink class to inherit from. The PolicyLink class contains information that links the policies with contacts via roles. It also contains information to facilitate policy searches. PegaIns-Interface-Contact This class inherits from PegaApp-Interface-Contact. It contains sample contact data used in PUI. This class is specialized to capture communication options (PegaIns Interface-Contact- CommunicationOptions). PegaIns-Interface-BusinessUnit This class inherits from PegaApp-Interface-BusinessUnit. It contains sample business data used in PUI. PegaIns-Interface-Roles This class inherits from PegaApp-Interface-Roles. It contains sample role data used in PUI, such as Applicant and InsuredParty. PegaIns-Interface-Agent This class inherits from PegaIns-Interface-. It contains sample data specific to agents. PegaIns-Interface-Agency This class inherits from PegaIns-Interface-. It contains sample data specific to agencies. An agency and an agent have a one-to-many relationship. PegaIns-Interface-Vehicles This class inherits from PegaIns-Interface-. It contains sample Vehicle data such as make, model, year, and so on. Pega Underwriting for Insurance Implementation Guide 2-42

50 This diagram shows the inheritance for the PegaIns-Interface-InsurancePolicy class: Pega Underwriting for Insurance Implementation Guide 2-43

51 3 Using PUI PUI Cases PUI is designed and implemented using the Pega 7 stage-based Case Management capabilities. This provides you with: A less rigid structure to build and modify process flows. More flexibility defining the sequence of tasks and deciding which tasks are needed. A view of the relationship of all stages and steps in cases. pystartcase activity triggers the first stage in the case type rule. Supporting processes and coverable work types can be added to the case type rule. Automatically and manually launched processes can be configured on the case type rule. Each stage and step can be conditionally handled using When rules and other out-ofthe-box case management features. A case type rule can be circumstanced depending on from which channel the work object is triggered. Pega Underwriting for Insurance Implementation Guide 3-1

52 The following figure shows the Case Explorer that you use to view the case types: The following submission case types are provided with PUI: Commercial General Liability Commercial Property Personal Auto Personal Umbrella Life Personal Bundle: Includes all Personal Lines LOB (e.g., Personal Auto, Umbrella). Commercial Package: Includes Commercial General Liability and Commercial Property LOB. Pega Underwriting for Insurance Implementation Guide 3-2

53 Each case type rule can be included in a bundle to launch as one work type (e.g., Personal Bundle and Commercial Package). Commercial Property This case type defines all the possible stages of the policy life cycle through policy issuance. A Commercial Property case type rule includes the following stages: Applicant Identification Risk Evaluation Agent Intake Account Data Application Underwriting Proposal Issue Decline Underwriting (Alternative) Proposal Rejected (Alternative) Pega Underwriting for Insurance Implementation Guide 3-3

54 Applicant Identification - This stage takes the applicant information (personal details and address) and validates them to ensure that this is not a duplicate applicant. If duplicate accounts are found, the system displays the duplicate records. Otherwise, the system creates a new customer record in the database. Risk Evaluation - The Risk Evaluation stage determines the risk appetite of the business that will be considered for underwriting purposes based on the SIC code (Standard Industrial Classification). An automated decision is made based on the appetite condition (Standard, Desirable, t Desirable). Agent Intake - Captures agent and agency information. Account Data - Captures property location information, building details, survey questionnaire related to risk evaluation, prior carrier information, and loss history. Application - Captures policy start date, additional information related to location and buildings, and quote variants. The user can select a combination of coverages and endorsements from among the quotes. Underwriting - The work object will be assigned to the Underwriter for a manual underwriting decision. The Underwriter can adjust the premium calculation and can approve or reject the application. Pega Underwriting for Insurance Implementation Guide 3-4

55 Proposal - Once the Underwriter approves the application, proposal correspondence will be sent to the agent or customer including the coverage selected. Issue - Once the proposal is accepted by the customer, the Bind process will run the Process Quote activity to issue a policy and generate a policy number. Decline Underwriting (Alternative) - Underwriter can reject the application using the Decline Underwriting alternative flow action. Proposal Reject (Alternative) If the proposal is rejected, the proposal case is resolved and the submission case is then resolved, providing the Underwriter with the opportunity to mark the submission to remarket prior to expiration. Similarly, define all the stages related to each LOB and configure the rules for each stage. Duplicate Search During the Applicant Identification stage, PUI compares the details entered for the new application against existing customers to identify potential duplicate customers. The user can select an existing customer if appropriate, or click Create New to create a new customer entry. The following figure shows an example of a list of existing customers with matching information. Pega Underwriting for Insurance Implementation Guide 3-5

56 To achieve this functionality, we used the D_BusinessUnitList Data Page. This data page takes the BusinessUnitID, BusinessUnitName and ZipCode entered for the customer during the Customer Intake step, and then returns matching results accordingly. Routing PUI presently routes the submission work object to an Underwriter after the quote has been accepted by the customer. This is mostly used in the commercial submission process. Most of the personal lines are straight through processes that are system-underwritten. Pega Underwriting for Insurance Implementation Guide 3-6

57 For example, once the Quote is accepted by the customer for a commercial GL submission, an appropriate SLA is defined for the work object and the work object is routed to John Henderson (Underwriter) for his review and approval. Similarly, the Commercial Property submission is routed to Dane Sax (Underwriter). Pega Underwriting for Insurance Implementation Guide 3-7

58 Routing to a Commercial Underwriter In the flow PegaIns-PAB-Work-Submission-Com ExecuteUnderwriting, the Underwriter work party is created by the Activity PegaIns-PAB-Work-Submission SetUnderwriterPartyDetails. Pega Underwriting for Insurance Implementation Guide 3-8

59 Pega Underwriting for Insurance Implementation Guide 3-9

60 The PegaIns-PAB-Work-Submission FindProductSpecificUnderwriter decision table determines the actual Underwriter operator to whom the submission work object will be routed, as shown below. As shown in the example above: If the LOB is Commercial GL, then the work object is routed to If the LOB is Commercial Property, then the work object is routed to If the LOB is Commercial Package, then the work object is routed to Otherwise, the work object is routed to but the routing is overridden in the CL, PL and ILA layer to match with the specific layers. Values in the decision table such as LOBs and Underwriter operators can be modified based on the client specific implementation. Correspondence Proposal The Coverage proposal correspondence is generated and sent to the agent. The proposal includes the Customer information and the Quote options available to offer to the customer for the selected Line of Business. The SendCorrespondence activity uses the ProposalCoverLetter correspondence rule to send the proposal to the agent or customer. Pega Underwriting for Insurance Implementation Guide 3-10

61 Once the Underwriter approves the application, an automated correspondence is sent to agent. If the Customer accepts the proposal, the work object is issued. Data Pages Data Pages help load data dynamically. This topic describes the data pages used in PUI. D_Customer Data Page Purpose This data page is used to get the customer details. The source for this data page is configured conditionally and the sources are the activities shown in the screenshot below. Pega Underwriting for Insurance Implementation Guide 3-11

62 Pega Underwriting for Insurance Implementation Guide 3-12

63 Usage The Usage tab of this data page shows you where it is used: Pega Underwriting for Insurance Implementation Guide 3-13

64 Example This data page is used to show selected customer details in the Personal Auto Submission process. D_BusinessUnitList Data Page Pega Underwriting for Insurance Implementation Guide 3-14

65 Purpose This data page is used to get the business unit details. The source for this data page is the report definition GetContacts of the PegaApp-Interface-Address class. A response data transform named BusinessCustomerListMapper is configured with the relevant mapping of the values obtained. Usage The Usage tab of this data page shows you where it is used: Pega Underwriting for Insurance Implementation Guide 3-15

66 Example This data page is used to fetch the business unit list in a customer search. D_AddressList Data Page Pega Underwriting for Insurance Implementation Guide 3-16

67 Purpose This data page is used to get the customer address details. The source for this data page is the report definition CPMGetPrimaryAddress of the PegaApp-Interface-Address class. A response data transform is configured with the relevant mapping of the values obtained. Usage The Usage tab of this data page shows you where it is used: While fetching business unit details and customer details, the data page fetches the customers address list. Pega Underwriting for Insurance Implementation Guide 3-17

68 D_CommunicationOptionsList Data Page Purpose This data page is used to get the customer details. The source for this data page is the report definition GetCommOptions of the PegaApp-Interface-Contact-CommunicationOptions class. A response data transform is configured with the relevant mapping of the values obtained. Pega Underwriting for Insurance Implementation Guide 3-18

69 Usage The Usage tab of this data page shows you where it is used: Example This data page is used in MCA to fetch the communication details. Pega Underwriting for Insurance Implementation Guide 3-19

70 Clipboard D_ContactList Data Page Pega Underwriting for Insurance Implementation Guide 3-20

71 Purpose This data page is used to get the customer contact details. The source for this data page is the report definition GetContacts of the PegaApp-Interface-Address class. A response data transform named BusinessCustomerListMapper is configured with the relevant mapping of the values obtained. Usage The Usage tab of this data page shows you where it is used: Example When you search for a contact on a customer search screen, a list of matching contacts is displayed. This data page fetches the contacts for that list. Pega Underwriting for Insurance Implementation Guide 3-21

72 User Experience Application Skin Starting in Pega 7.1, a best practice is to associate a single skin with your application. By default, a portal points to the skin specified in the application, ensuring that all portals in your application have the same look and feel. Pega Underwriting for Insurance Implementation Guide 3-22

73 PUI is provided with the PFUFEndUser71 skin. This can be set up on the Definition tab of the Application rule. The following figure shows an example of that skin. Pega Underwriting for Insurance Implementation Guide 3-23

74 Setting the skin on the portal The skin setting on the portal rule indicates whether the portal is rendered in the application skin or rendered in a skin specified for the portal. Select the Default to Application Skin option for the portal skin if the portal will use the skin associated with the application. HTML5 Application Readiness The HTML5 Application Readiness landing page is used to upgrade a pre-pega 7 application to render in the HTML5 document type. Applications built in Pega 7 use the HTML5 document type by default. Rendering the user interface in the HTML5 document type ensures cross-platform compatibility, use of the latest HTML markup, and improved performance, among other benefits. It also ensures that you can take advantage of all of the new features in Pega 7, including the following responsive, contemporary layouts that enable you to separate content from presentation: Screen Layouts Dynamic Layouts Column Layouts Pega Underwriting for Insurance Implementation Guide 3-24

75 The following figure shows how to access the HTML5 Application Readiness landing page. Dynamic Layouts A dynamic layout is a DIV-based layout that allows for highly flexible display of content. Dynamic layouts separate content and presentation. A number of dynamic layout formats are available in the skin, including: Default, Stacked, Inline, Inline grid double, and Inline grid triple. You can modify and create additional formats. Changing the format in the skin automatically affects all sections using that format. Dynamic layouts can be nested within other dynamic layouts. As a best practice, use dynamic layouts when developing a UI for applications that are rendered in the HTML5 document type (standards mode). Pega Underwriting for Insurance Implementation Guide 3-25

76 Adding a Dynamic Layout In the harness or section, click Layout, and then select Layout. On the Set Layout Type dialog, select Dynamic Layout. The Dynamic Layout displays. Pega Underwriting for Insurance Implementation Guide 3-26

77 Click to open the Dynamic layout properties panel. On the Dynamic Layout properties panel, define the dynamic layout using the General and Presentation Tabs. Select DesignerStudio > User Interface > UI Gallery and then select Stacked Dynamic Layout in the Layouts and Containers group to see examples of different dynamic layouts configurations. UI Inspector The UI Inspector tool enables developers and designers to easily review the structure of the application in the context of Pega 7 UI rules and elements. Similar to the HTML inspector tools found in most browsers, the UI Inspector tool highlights elements such as harnesses, panels, sections, layouts, flow actions, cells and properties. As you use the cursor to point to different elements in the application UI, the UI Inspector highlights each element type with a red outline. Pause briefly while any element is in focus to see a panel with detailed information about the element's structure and configuration. Using the UI Inspector Once enabled, the UI Inspector immediately detects UI elements in your application. Outline indicators update in real-time as you point to different elements. Click the button label to turn on the tool: Pega Underwriting for Insurance Implementation Guide 3-27

78 4 PUI Deep Dive Submission and Application In the submission and application processes, work objects are created for different lines of business. PUI covers the following submission processes: Life Submission Personal Auto Submission Personal Umbrella Submission Commercial Property Commercial General Liability Personal Bundle Submission. Includes the following LOB Application work objects: Personal Auto Submission Life Submission Personal Umbrella Submission Commercial Package Submission. Includes the following LOB Application work objects: Commercial General Liability Commercial Property te: In PUI 7.13, all of the Submission processes are bifurcated into relevant layers. Commercial Lines submissions can be processed from the Commercial Lines Implementation layer, Personal Lines submissions can be processed from the Personal Line Implementation layer, and Individual Life and Annuity submissions can be processed from the Individual Life and Annuity Implementation layer. In PUI 7.11, a new personal bundle submission process is introduced which was not part of the earlier versions. In earlier PUI versions, personal auto, life, and personal umbrella were implemented as mono-line submission processes that are still part of PUI 7.11 added the ability to initiate a personal bundle submission which will handle the above mentioned Personal LOBs (product lines) in a single bundle submission work object. It is especially useful when a carrier is interested in offering multiple personal lines to a customer under a single personal bundle submission. Submission - General and Specific Flows In PUI versions prior to 6.3, the generic flow StartSubmission of the class PegaIns-PAB-Work- Submission was called to initiate a submission. This was specialized in the respective LOB specific classes, and a NewWork generalized flow was called from these flows for all LOBs. With the implementation of stage based case management starting in PUI 7.1, all the starter flows are now initiated by the respective LOB specific pydefault case type rules. In PUI 7.1 and higher, case stages control the submission process. All the flows and sub flows are called from the steps of these stages. In fact, each step represents a flow in a stage. Pega Underwriting for Insurance Implementation Guide 4-1

79 The following figure shows the personal auto case type rule: te: Additional information about case management such as pydefault case type rule configuration is provided in the Using Case Management topic in Chapter 2. Some important generic and specific flows The following table illustrates generic and specific flows: Flow Name CreateSubmissionPage CustomerManagement AccountDuplicateCheck IntakeAgent GetPolicyEffectiveDate ProductSelection ProductSelection CollectApplicationDetails Class PegaIns-PAB-Work-Submission PegaIns-Work PegaIns-Work PegaIns-PAB-Work-Submission PegaIns-PAB-Work-Submission PegaIns-PAB-Work-Submission (This is generic for all mono-line submissions including both personal and commercial.) PegaIns-PAB-Work-Submission-Package (This is common for both personal bundle and commercial package only.) PegaIns-Data-Application (This is a generic top level flow that is specialized in all LOB Pega Underwriting for Insurance Implementation Guide 4-2

80 Flow Name RiskEvaluation AppetiteDetermination SetUWStatus Billing ExecuteBind Class specific classes.) PegaIns-PAB-Work-Submission (Common to commercial submissions only.) PegaIns-Data-Submission (Common to commercial submissions only.) PegaIns-PAB-Work-Submission PegaIns-PAB-Work-Submission PegaIns-PAB-Work-Submission Submission and Application-- Personal Lines PUI includes the following personal product lines: Personal Auto Personal Umbrella Life Personal Bundle: A personal package submission that includes all of the above The starter flows for these LOBs are initiated by the pydefault Case Type rule. These rules are defined in the respective LOB-specific classes as shown below: Personal Auto: PegaIns-PAB-Work-Submission-Pers-Auto Personal Umbrella: PegaIns-PAB-Work-Submission-Pers-Umbrella Life: PegaIns-PAB-Work-Submission-Life Personal Bundle: PegaIns-PAB-Work-Submission-Package-Pers The personal lines submission process includes the following steps; some additional steps are required only for Personal Auto): Initialize Submission and Applicant Identification Agent/Agency Association Quote: Set product data and collect LOB specific application details Collect additional application details and proceed to Billing Underwriting, cross/up sell Issue the policy Pega Underwriting for Insurance Implementation Guide 4-3

81 Initialize Submission and Applicant Identification: This step presents the processes to enter the customer details and determine whether there are duplicate accounts. This flow is in the PegaIns-Work class and reusable for all lines of business. If a contact is selected from the search result list, then a covered submission case is added to the CA cover object. Otherwise, a new contact is created with the given search information and the CA cover is created. This is achieved by the activity AddCaseToCustomer of the class PegaIns-Work. This activity is same for all LOBs. te: For more information about contact and business unit creation, see Managing a Customer Account (MCA) on page Account verification Pega Underwriting for Insurance Implementation Guide 4-4

82 Adding CA Cover Case CA Cover object clipboard Pega Underwriting for Insurance Implementation Guide 4-5

83 Agent/Agency Association This step displays when an agents or agency is associated with the customer. This sub flow is part of the PegaIns-PAB-Work-Submission flow and serves the same function across all lines of business. Quote Stage: Set product data and collect LOB-specific application details In the mono-line personal submission, application data is set on the page ApplicationPage under the submission pyworkpage. The activity SetProductData of the class PegaIns-PAB- Work-Submission is used to set data such as ProductName. The ProductType on the ApplicationPage and the class of ApplicationPage is determined by the Map Value rule ApplicationClassForComm. The ProductName class of the ApplicationPage is determined by this Map Value rule. Pega Underwriting for Insurance Implementation Guide 4-6

84 Map Value rule For Personal Auto, the following figure shows the ApplicationPage on the clipboard: The flow rule CollectApplicationDetails is used to collect LOB-specific data to process the quote. This rule is defined in the general class PegaIns-Data-Application and is specialized in the LOBspecific classes. Pega Underwriting for Insurance Implementation Guide 4-7

85 For example, the Personal Auto flow is defined in the class PegaIns-Data-Application-Pers- Auto. The other LOBs are defined in a similar fashion. The following figures show the application data LOB specific classes: Pega Underwriting for Insurance Implementation Guide 4-8

86 Pega Underwriting for Insurance Implementation Guide 4-9

87 The following figure shows the CollectApplicationDetails flow in a Life submission: Pega Underwriting for Insurance Implementation Guide 4-10

88 The following figure shows the clipboard structure of ApplicationData for Life submission: Pega Underwriting for Insurance Implementation Guide 4-11

89 The following figure shows the clipboard structure of ApplicationData for personal Auto: The CollectAdditionalApplicationDetails flow of the class PegaIns-PAB-Work-Submission is used to collect extra information about the LOB specific data at the Application stage. This is presently used only in the case of Personal Auto to collect additional details like SSN, License number, VIN, annual mileage, and so on. This flow initiates another flow called CollectAdditionalApplicationData of the class PegaIns-Data-Application, and is again specialized in the LOB specific class of Personal Auto. This is the actual flow that collects additional application details in the LOB specific classes. This can be extended for other LOBs if required. Pega Underwriting for Insurance Implementation Guide 4-12

90 The following figure shows the submission classes for personal lines: Pega Underwriting for Insurance Implementation Guide 4-13

91 Personal Bundle The following figure shows the Personal bundle case type rule: All the personal LOBs are coverable work objects under the PegaIns-PAB-Work-Submission- Package-Pers pydefault case type rule as shown below. In the case of a personal bundle submission, an ApplicationList page list is created to capture the LOB-specific data instead of the ApplicationPage that is created for individual submissions. Pega Underwriting for Insurance Implementation Guide 4-14

92 One ApplicationList() page is created for each LOB that is selected in the bundle. The following figure shows where the LOBs (desired products) are selected in the bundle. The activity SetProductData of the class PegaIns-PAB-Work-Submission-Package loops through all the selected LOBs, creates an ApplicationList Page list, and then assigns the appropriate class to each page in the ApplicationList page list based on the Map Value rule ApplicationClassForComm of the class PegaIns-Data-Application. tice that in a mono-line personal submission, the SetProductData activity (explained earlier) creates an ApplicationPage whereas for a bundle it creates the ApplicationList page list to accommodate all the selected LOBs. The classes for a mono-line submission and a package (i.e., bundle) submission are also different from each other. One is in PegaIns-PAB-Work-Submission and the other one is in PegaIns-PAB-Work-Submission-Package. When the personal bundle process reaches the Underwriting stage, the activity CreateApplicationCase of the class PegaIns-PAB-Work-Submission-Package (called from the flow CreateSubmissionCase of the same class) creates individual submission work objects (sub cases) for all the LOBs selected, and then adds them as child objects to the personal bundle submission. The appropriate class for the individual submission child work objects is assigned by the Map Value rule DetermineApplicationClassByProduct of the class PegaIns-Data- Application. Pega Underwriting for Insurance Implementation Guide 4-15

93 The following figure shows the CreateApplicationCase activity: te: At the Applicant Identification stage of each individual submission process, there is a flow called CheckForBundling that checks whether the submission (pystartcase) is initiated by the bundle. This is done using the When rule BundleIdtEmpty. The When rule checks for a property called BundleId. If the BundleId is not empty (that means the submission-pystartcase-is initiated as part of the submission bundle), then the case type rule directly invokes the child submission process from the Underwriting stage (skipping the preceding stages) as shown in the figure below. This is done to avoid running all the stages (up to the Underwriting stage) of individual submission cases that are invoked as part of Bundle, because those stages have already been taken care of by the Bundle work object. In other words, when a personal bundle or commercial package submission reaches the Underwriting stage, the required child submission work objects have to be created for each LOB selected in the bundle or package and sent to the Underwriters for approval. To achieve this, the child submission cases are directly invoked from the Underwriter stage (skipping the preceding stages) when these child submission cases are triggered by the above activity. Pega Underwriting for Insurance Implementation Guide 4-16

94 In the following figure, the pystartcase flow and the application class name are passed as parameters to the pyaddchildwork activity. The following figures show the Map Value rule to determine the class for each line of business: Pega Underwriting for Insurance Implementation Guide 4-17

95 Billing Billing is a process by which a consideration is received from the customer by the carrier or insurer in return for the insurance contract or insurance product offered by the insurer. Simply put, it is how the premium is collected by the insurer from the customer using several payment options such as credit card, check, online money transfer, and so on. The Billing process shows the entire premium breakdown for a policy, payment options, methods, payment modes, payment frequency, premium deposit, discounts, and so on. In PUI 7.13, only the personal lines have the billing process. All personal lines have a billing flow during the Application stage. For mono-line personal submissions, only this Billing flow is invoked from the LOB (mono-line specific) specific case type rule. If the submission object is a personal bundle, then the Billing flows in the mono-line case type rules are skipped and the flows are executed from the bundle flow. The When rule BundleIdIsEmpty in the mono-line billing step configuration controls this. The flow rule used is named Billing and it is of the class PegaIns-PAB-Work-Submission. This is the common flow for all the personal LOBs. Even the personal bundle submission invokes the same flow. Pega Underwriting for Insurance Implementation Guide 4-18

96 The following figure shows the Billing screen from a Personal Umbrella submission: As explained earlier in the Data Classes topics in Chapter 2, the data class PegaIns-Data- PremiumBilling is used to capture the Billing details. Pega Underwriting for Insurance Implementation Guide 4-19

97 The following figure shows the clipboard page structure. Binding and Policy Issuance Binding is an agreement of coverage issued by an agent or insurance company before a policy has been officially issued. In other words, it is an act of imposing a duty to keep the commitment. The submission has to successfully pass through the underwriting Approval stage in order for a binder to be issued. For both personal and commercial mono-line submissions, the BindPolicy step in the Issue stage invokes the flow ExecuteBind of the class PegaIns-PAB-Work- Submission. This is the common flow used for binding the policy in all mono-line submissions. This flow triggers the activity IssueQuote of the class PegaIns-PAB- Work-Submission. Pega Underwriting for Insurance Implementation Guide 4-20

98 The following figure shows the Bind policy step in the Life submission case type rule: The following figure shows the ExecuteBind flow: The data transform SetPolicyPrefix in the IssueQuote activity first sets the appropriate policy prefix. This data transform is specialized in the LOB specific PegaIns-Data-InsurancePolicy classes. For example, for personal auto, a PA prefix is set. Next, the parameter for the Quote Pega Underwriting for Insurance Implementation Guide 4-21

99 Status is set to be passed to the activity BindNextGenPolicy. The UpdateQuoteStatus data transform is called to set the quote status to Quote-Issued if the Quote is not rejected by the Underwriter. In the next step, a unique policy ID is set before calling the BindNextGenPolicy activity. The following figure shows the IssueQuote activity: The BindNextGenPolicy activity prepares the data to be saved and persisted in the PegaIns- Interface-InsurancePolicy class. This activity does the following: Sets the appropriate policy data. Sets the policy holder work party. Prepares a new page InsurancePolicy of the class PegaIns-Interface-InsurancePolicy. Copies the PolicyData from the Quote page to the InsurancePolicy page. Calls the WriteNextGenPolicy activity to copy the work party data, agent, and agency information into the parties to agreement pagelist under the InsurancePolicy page, and saves (Obj-Save) the PegaIns-Interface-InsurancePolicy. Pega Underwriting for Insurance Implementation Guide 4-22

100 The following figure shows the BindNextGenPolicy activity: Pega Underwriting for Insurance Implementation Guide 4-23

101 The following figure shows the WriteNextGenPolicy activity: Pega Underwriting for Insurance Implementation Guide 4-24

102 The following figure shows the PegaIns-Interface-InsurancePolicy page that is persisted in the database: In the case of personal bundle and commercial package submissions, the ExecuteBind flow of the class PegaIns-PAB-Work-Submission-Package is invoked. This flow first updates the quote status similar to the quote update process and then launches the IssueQuote activity of the class PegaIns-PAB-Work-Submission-Package. tice that this Pega Underwriting for Insurance Implementation Guide 4-25

103 activity's class is different from that of the mono-lines' IssueQuote activity explained earlier in this topic. In the case of personal bundle and commercial package submissions, the PegaIns-Interface- InsurancePolicy page has to be populated multiple times by looping through the ApplicationList page list. So the same process that is followed in the IssueQuote activity in mono-line submission has to be repeated multiple times in this activity in order to persist multiple policies that are issued in a bundle or package. That explains why this activity is specialized in the package classes of personal bundle and commercial package. The following figure shows the IssueQuote activity of package classes: Quote An insurance quote is an estimate of what your rate could be with a potential insurance carrier. Quotes are subject to change depending on how much information you give at the time of the application. The more forthcoming you are with information, the more accurate your insurance quote will be. This estimated premium is based on several factors such as: type of insurance, coverage amount requested, length of coverage, age, gender, health and medical history, and family history. For commercial insurance, factors also include: location of property, safety and security features, building construction type, fire protection class, and so on. Pega Underwriting for Insurance Implementation Guide 4-26

104 The quote process is primarily an estimation of preliminary rates. The final rates will be determined by the carrier's underwriting process once the quote is accepted by the carrier. In PUI, all of the LOBs have a Quote step in the Application Stage. It is part of the screen flow that collects application and LOB specific-data, and it shows the Quote screen based on the application information provided by the customer. There is a base screen flow named CollectApplicationDetails (of the PegaIns-Data-Application class) that is specialized in the LOBspecific classes. Depending on the LOB, the class-appropriate screen flow and corresponding Quote screen is triggered at run time. For example, for the Life submission, the CollectApplicationDetails screen flow of the class PegaIns- Data-Application-Comm-Property is run at run time. The following figure shows the Life submission screen flow: The following figure shows the LOB-specific classes for the CollectApplicationDetails flow: Pega Underwriting for Insurance Implementation Guide 4-27

105 The following table shows the high level steps in the Quote process: Quote Process Load the appropriate LOB specific coverages, allowed limits, deductibles, surcharges and discounts etc. from PBI (Product Builder for Insurance, a.k.a. PCF in earlier 6.3 versions of PUI) and populate them on the Quote screen Coverage Selection Calculate Premium Finish/Accept Quote Who does this process? System: based LOB, Effective date, Jurisdiction and Product name. User System: based on some declare expressions (Explained in detail in 'Pricing' section) User te: PBI is part of the PUI 7.13 installation. For information about PBI implementation, see the PBI Implementation Guide. The Quote step screen flow shown in the previous figure invokes a flow action named ManageCoverages that displays a section named ManageCoverages. This is the section that displays the Quote screen with the required LOB-specific coverages, deductibles, allowed limits, and other information fetched from PBI. This flow action and section are also specialized in the LOB-specific PegaIns-Data-Application classes. Data classes in Quotes The Quote page has premium details and coverage details. The following data classes are reused for lines of business when generating quotes: PegaIns-Data-Quote Stores quote or multiple quotes details PegaIns-Data-PolCmp-CoverageComponent Holds coverages and can be reused for all lines of business. PegaIns-Data-InsurancePolicy-Commercial-Property and PegaIns-Data- PolCmpInsuredBusinessBuilding Store property-specific data for commercial lines. PegaIns-Data-ManualPremiumAdjustment Stores adjustment amount in premium calculations. PegaIns-Data-DiscountCodes Stores discount codes in premium calculations and can be reused for all lines of business. PegaIns-Data-PolCmp-Limit Stores allowable limit values for each coverage selected. PegaIns-Data-PolCmp-Deductible Stores the deductible values for each coverage selected. PegaIns-Data-PremiumBilling Stores the billing related details. Pega Underwriting for Insurance Implementation Guide 4-28

106 Configuring Quotes A pre-processing activity named SelectProducts defined in the ManageCoverages flow action does the job of fetching the LOB specific policy level coverages, risk coverages, allowed limits, deductibles, and so on from PBI. This activity accepts the following parameters to fetch details from PBI: The LOB parameter is just the Product Name. The jurisdiction parameter is the state of garaging location. The EffectiveDate parameter is the policy effective date. Using these parameters, the D_ProductOptions data page is initiated. That data page is sourced by the activity LoadProductOptions. This activity, at a very high level, browses the class Rule-InsProd- ProductOptions for a specific product (Rule-InsProd-Product) in PBI, based on the LOB and effective date, and then populates the data page with that information. These product options from the data page are copied over to the ProductsList page of the class code-pega-list. For each product option in the pxresults list of ProductList, a corresponding Pega Underwriting for Insurance Implementation Guide 4-29

107 Quote page (of the class PegaIns-Data-Quote) is created under Quotes page list. The required data is populated in the Quote pages under the Quotes page list with the help of the data transform MapProductToQuote. Through this data transform, all the coverages are mapped to the section CommCoverages (of the class PegaIns-Data-PolCmp-CoverageComponent), limits are mapped to the section Limits (of the class PegaIns-Data-PolCmp-Limit) and deductibles are mapped to the section Deductibles (of the class PegaIns-Data-PolCmp-Deductible), and the PolicyData page list (of the class PegaIns- Data-InsurancePolicy) is copied to the respective pages in Quotes pagelist to store all the policy related data into each Quote. Pega Underwriting for Insurance Implementation Guide 4-30

108 As shown in these figures, Step-6 is where the Quote pages are created as page lists for the corresponding product options in PBI. For Personal Auto LOB, PBI is configured to have covered risks as well as policy level coverages. The SelectProduct activity calls the CopyRiskData activity, which gets the risk coverages pages from the temporary clipboard page (TempProductPage, populated from PBI). The activity then maps them back to the CoveredVehicles pagelist under the Quotes > PolicyData page. The mapping is managed by the data transform MapRiskCoverages. Pega Underwriting for Insurance Implementation Guide 4-31

109 The following figure shows the CopyRiskData activity: te: The SelectProducts activity and the data page D_ProductOptions are complex and do a lot of the work for you. Each Line of business uses the same activity. During configuration of the products and risks, the data is mapped for you. If you extend your product structure, you may need to modify the SelectProducts activity or one of the data transforms to add any customer-specific entities. After the initial work is done, additional tweaks can be done on the products. Consider the SelectProducts and D_ProductOptions to be the core APIs for integrating PUI with PBI. While the quotes structure from PBI is being copied to the Quotes page list via the activity SelectProducts (explained earlier in this topic), the initial Quote-Status is set to Quote-Draft. After the Quote is accepted by the user, its status changes to Quote-Proposed and the work object status is set to Application-Bind. This is achieved by the post-processing activity ChangeStatus in the ManageCoverages flow action. This activity calls another activity which handles the required validations, sets the Quote-Proposed status, and copies the selected Quote from the Quotes pagelist to the SelectedQuote top level page. This is the base page for all of the subsequent processes such as Underwriting, Billing, and so on. Pega Underwriting for Insurance Implementation Guide 4-32

110 The following figures show these activities: Product Variances Product options are different variants of coverage offerings that a carrier provides to the customer for an LOB. t all products in PUI have product options. Based on the product Pega Underwriting for Insurance Implementation Guide 4-33

111 options defined in PBI for an LOB, Quote screens are pre-populated with coverage limits, deductibles, and an estimated preliminary premium. The user may select any of these options or they may opt to define their own coverages by choosing the custom option. Other LOBs do not currently have any product options and variants. LOB Product Options Personal Auto Gold Silver Custom (which can be customized) Life 10 yr Term Life 200K 5 yr Term 100K 30 yr Term Custom -Term Life Variable Universal Life Whole Life The following figure shows the Life Policy Product Options: Pega Underwriting for Insurance Implementation Guide 4-34

112 The following figure shows the Personal Auto Product Options: Pega Underwriting for Insurance Implementation Guide 4-35

113 Risk level coverages are also loaded from PBI if they are configured in PBI already for an LOB. For example, in the personal auto Quote screen shown above, the risk level coverage (vehicles are the risk in personal auto policy) are also shown below the policy level coverages. The expanded screen shot below shows the comprehensive and collision risk level coverages that are loaded from PBI: Quotes Clipboard Structure: Quotes are mapped from PBI Products and Product Options to the classes Rule-InsProd- Product and Rule-InsProd-ProductOptions respectively. Each Quote in the Quotes page list below corresponds to its respective product option in PBI. There will be as many quotes mapped to the quotes structure as there are product options in PBI for a specific LOB. For LOBs that do not have product options, we can still have multiple pages in the Quotes pagelist by adding or appending a quote in the UI. We can add any number of quotes to see, compare, and verify quotes before accepting one of them. Pega Underwriting for Insurance Implementation Guide 4-36

114 The following figure shows an example commercial property Quotes screen. Pega Underwriting for Insurance Implementation Guide 4-37

115 Coverages are held in the CommCoverage pagelist as shown below. Pega Underwriting for Insurance Implementation Guide 4-38

116 CommCoverages pages (see the figure below) contain other pages to represent limits, deductibles, surcharges, and discounts if applicable. Pega Underwriting for Insurance Implementation Guide 4-39

117 Risk level coverages appear under the PolicyData > CoveredVehicles > CommCoverages page list. Only Personal Auto currently has this mapping from PBI. For example, the personal auto LOB clipboard structure in the following figure shows that risk level coverages (Collision and Comprehensive) for each vehicle (vehicle is the risk in personal auto) are represented under the CoveredVehicles > CommCoverages pagelist. Each CommCoverage page holds details such as coverage code, coverage name, premium, and so on. Pega Underwriting for Insurance Implementation Guide 4-40

118 Coverage List Each LOB has its own coverages, limits, and deductibles. The following table lists the LOB specific coverages presently defined in PBI and shown on the respective LOB-specific Quote screen. LOB Coverages Personal Auto Bodily Injury PIP Uninsured Motorist Underinsured Motorist Med Pay Towing Property Damage Substitute Transportation Comprehensive Collision Personal Umbrella Liability Term Life Term Death Benefit Whole Life and Variable Universal Life Death Benefit te: In PUI 6.3 and earlier, the Quote process varies from the current process. Previously, a supporting process called Generate Quote used to generate quotes. And the products were fetched from the PCF Structure. w, The Generate Quote process is part of the main Application process and no longer just a supporting process. All of the products, product options, risks, product forms, price adjustments, product lines, coverages, limits, deductibles, surcharges, and discounts are now directly driven by PBI. PUI fetches them into the application clipboard structure and references them appropriately. Clients can create their own products, coverages, risks, and so on, or they can modify the existing ones by saving them to their own rule sets. Pega Underwriting for Insurance Implementation Guide 4-41

119 Survey PegaSurvey enables users to create surveys and quizzes. PegaSurvey includes a variety of question types, and other useful features. It is a horizontal framework that can be used across any domain to capture feedback or conduct quizzes. Survey Structure When you create a survey, you create a package of rules that can be more or less complex depending on the type of questions you want to ask. You can create new assets for every survey you create, but it is more likely that you will develop a catalog of standard questions that you can reuse in many surveys. The following figure shows how the pieces of PegaSurvey fit together: The top-level rule is a survey. Within the survey, you include at least one question page, which is a group of questions (there are two types, Simple and Complex) usually related to a single category of Information. A question page can have as few as one question or as many as are needed to capture the information being surveyed. Question pages can contain the following types question types: Simple Question - A single line-item question. For example: Are you full-time or contract? Complex Question - A group of questions with a unified response method such as a set of radio buttons or check boxes. Examples: Select the answer, or Select all that apply. After you create the questions you need, group them in question pages, and add the pages to a survey in the sequence that you want them to appear, the survey is ready to use in a flow. Pega Underwriting for Insurance Implementation Guide 4-42

120 Creating and Managing Surveys in PUI PegaSurvey is an independent horizontal framework, but it is packaged with PUI. PegaSurvey rules are contained in a ruleset called PegaSurvey that is included in the PegaInsurance application stack. The Survey Management landing page provides access to tools and resources that simplify the task of creating and maintaining surveys and survey assets. The landing page displays two tabs: My Surveys The main tool for creating questions, question pages, and surveys. Group Builder The tool that helps you organize related surveys into groups for delivery, and manage existing groups. From this tab, you can create surveys, question pages, and questions. You can also browse or search for existing surveys, pages, and questions, and then edit, copy, or delete survey assets that you find. PUI uses several surveys in the various submission processes. These are invoked using the section rule named SurveySection. This section accepts a Survey rule name as a parameter. Surveys work only on work pages; they do not work on data pages. For that reason, PUI references pyworkpage whenever a survey is to be displayed from a flow in a data class. An example is the Medical Information collected as part of the Life Submission process. The section used from the flow is PegaIns-Data-Application-Life, CollectMedicalInformation. Pega Underwriting for Insurance Implementation Guide 4-43

121 In this section, SurveySection is used as a Section Include as shown in the screenshot below. Pega Underwriting for Insurance Implementation Guide 4-44

122 The page context is provided as pyworkpage. The parameter page shown below accepts the survey rule name, which is MedicalInfoForLife in this example. This survey is created in the Submission work class so that it can be reused from Life Submission as well as from Personal Bundle Submission. Pega Underwriting for Insurance Implementation Guide 4-45

123 This survey (see the following figure) contains several question pages. Each question page depicts a list of survey questions. The MedicalQ1 question page is shown below: Pega Underwriting for Insurance Implementation Guide 4-46

124 In the following example, Medical1 and Medical1Explanation are the actual survey questions. The question and answers tab for this rule are shown below. Pega Underwriting for Insurance Implementation Guide 4-47

125 At runtime, the survey is rendered as shown below: Pega Underwriting for Insurance Implementation Guide 4-48

126 The clipboard structure for the survey is shown below: Other Surveys preconfigured in PUI include: GeneralDataEntry - To collect general information for commercial submissions (GL, Property, and Package). DataEntryGL To collect information during the Contractors step of the GL submission process. ProductsOperations- To collect information related to products and completed operations in the GL submission process. GeneralInformation To collect general information related to the GL Submission process. Pega Underwriting for Insurance Implementation Guide 4-49

127 Managing a Customer Account (MCA) The customer account management process provides a comprehensive, unified view of a customer s profile details, such as personal information, previous claims details, policies linked to the customer, and customer activities. It also includes the following capabilities: create a new customer (either individual or business), open an existing customer and view the details, update existing customer details. When a new customer is created, an MCA work object is created and linked to the Customer record. The MCA work object will be maintained as a long running object. There is only one MCA work object per customer. Accessing the MCA work object for a Customer Open the Case Manager Portal and click the Customer Management tab. Enter a value in the Last Name field, and then click Search. A list of matching customer records is displayed as shown in the example below. To open the MCA work object of a customer for further actions, click the Last Name or First Name link of the desired customer in the search results. The following figure shows the MCA screen for a sample customer named Natalie Song. 1. In the case manager portal, click the Customer Management tab. 2. Enter song in the Last Name field, and then click Search. Pega Underwriting for Insurance Implementation Guide 4-50

128 If the MCA work object exists, then it can be opened by clicking last name or first name link in the list. If no MCA work object exists for the customer, then it is created on-the-fly when you click the last name or first name link. The activity PegaIns-Data-Party- CheckForCAID checks if the MCA already exists. If it does not, it will create a new MCA work object and link it to the OwnerId. Pega Underwriting for Insurance Implementation Guide 4-51

129 The following figure shows the MCA work object for the sample customer Natalie Song: Several actions can be taken from the Actions menu of the MCA work object related to managing the customer s account, including: updating the customer profile, adding attachments, and so on. New submissions (e.g., life, personal auto, and so on) and a request for a policy loan can also be initiated via the Add work menu in the Actions area. MCA Technical Configuration The following activities create a new contact and MCA work object for that contact respectively: PegaIns-Work SaveNewContactInfo PegaIns- CreateManageCustomerAccount The MCA work object is saved in the IIF_WORK database table and is linked to the customer via OwnerId. For a business customer, the following activity is used before creating a MCA work object: PegaIns-Work SaveNewBUInformation. Pega Underwriting for Insurance Implementation Guide 4-52

130 A new customer is created from the Customer Search screen as shown below: To create a new customer, click Create New. A window opens so that you can enter the appropriate customer details for the new contact or new business. Search Contact or Business Unit Technical Configuration On the customer management screen there are two search options: you can search for either an individual customer or a business customer. Pega Underwriting for Insurance Implementation Guide 4-53

131 Searching for a Customer When a user searches for an individual customer by criteria such as Last Name, First Name, and ContactId, this property (i.e., the search criteria) is set on the clipboard page named CustomerSearch of the class PegaIns-Work-ManageCustomerAccount and is also sent to the D_ContactList data page as a parameter. By taking this parameter as an input, the data page populates the data in the clipboard. The following figure shows the clipboard structure: Pega Underwriting for Insurance Implementation Guide 4-54

132 The following figure shows the parameters accepted by this data page: This returned search results list appears in the UI in a repeating grid when the user clicks the Search button. This D_ContactList data page is populated by the report definition rule named GetContacts of the class PegaApp-Interface-Contact. This class is a Customer Process Manager for Insurance (CPMI) class used for saving and retrieving contacts. We reuse this by having it as a direct parent to the PegaIns-Interface-Contact. Both of these classes are mapped to the PA_CONTACT table in the PegaDATA database. Once the data is fetched from PegaApp- Interface-Contact, it is renormalized back into the data layer (PegaIns-Data-Party-Person). te: See the Data Pages topic in Chapter 2 for more details about the data pages used in PUI. As mentioned earlier in this chapter, when a user clicks the First Name or Last Name link of a contact in the search results, the corresponding MCA work object opens up if it already exists or else a new MCA work object is created on the fly and opens. The latter scenario is typically encountered when a user creates a new contact from CPMI. From CPMI, a contact record is created and saved in the tables PA_CONTACT, PA_ADDRESS, PA_COMMUNICATION_OPTIONS, and so on, but no MCA object is created because CPMI does not have the MCA management process included in PUI.) In the Actions tab of the First Name, Last Name link properties panel, an OnClick event is defined that runs an activity called CheckForCAID (of the class PegaIns-Data-Party-) to check if the MCA work object already exists. If it does not exist, then the activity creates a new MCA work object and opens it. If the MCA work object exists, then the action Open-Work-By-Handle opens the MCA. Pega Underwriting for Insurance Implementation Guide 4-55

133 The following figure shows the First Name link properties panel: Pega Underwriting for Insurance Implementation Guide 4-56

134 The following figure shows the CheckForCAID activity: Pega Underwriting for Insurance Implementation Guide 4-57

135 The following figure shows the CreateManageCustomerAccount generic activity: Pega Underwriting for Insurance Implementation Guide 4-58

136 The following figure shows the D_ContactList: Business Search In the case of a business search, the D_BusinessUnitList data page populates the business units search results using the same report definition that was used to fetch the individual contacts, and it renormalizes the data back to the data layer (PegaIns-Data-Party-Org- Company) using the data transform rule BusinessCustomerListMapper. Pega Underwriting for Insurance Implementation Guide 4-59

137 The following figure shows the data page used in this context: Create New Contact and New Business Unit Technical Configuration When a search yields no results, then a new customer can be created by clicking the Create New button. Pega Underwriting for Insurance Implementation Guide 4-60

138 The following figure shows the Create New button on the Customer Search screen: Create New flow action This Create New button launches a local action named CreateNewContact to collect details about the new individual customer. The details are circumstanced if the customer is business customer. Pega Underwriting for Insurance Implementation Guide 4-61

139 The following figure shows the CreateNewContact flow action for an individual customer: The following figure shows the CreateNewCustomer flow action for a business customer: Pega Underwriting for Insurance Implementation Guide 4-62

140 The following figure shows the Create New Customer screen that is used to collect a new individual customer: The following figure shows the Create New Customer screen that is used to collect a new business customer: Pega Underwriting for Insurance Implementation Guide 4-63

141 The following figure shows the on configuration of the Create New button in the section rule CustomerSearchBusinessGrid of the class PegaIns-Work-ManageCustomerAccount. An OnClick event is defined to launch the flow action CreateNewContact. Individual customer creation main activity the post processing actions for the CreateNewCustomer flow action includes a main activity called SaveNewContactInfo of the class PegaIns-Work that is defined to persist an individual customer's data to the appropriate database tables (PA_CONTACT, PA_ADDRESS, PA_COMMUNICATIONS_OPTIONS, and so on) and also creates a new record in the MCA. Pega Underwriting for Insurance Implementation Guide 4-64

142 The following figure shows the main activity SaveNewContactInfo: The activities that are called from the main activity include the following: SaveContactInformation of the class PegaIns-Interface-Contact SaveAddressInformation of the class PegaApp-Interface-Address SaveCommunicationInformation of the class PegaApp-Interface-Contact- CommunicationOptions CreateManageCustomerAccount of the class PegaIns- The SaveContactInformation activity saves the contact data from the temporary page NewContactPage of the class PegaIns-Data-Party-Person to the PegaIns-Interface-Contact Pega Underwriting for Insurance Implementation Guide 4-65

143 class, which is mapped to the PA_CONTACT database table. The data transform renormalizes the data to the interface layer RenormalizeCustomer of the class PegaIns-Interface-Contact. Similarly, address information and communication information is also renormalized and saved to the respective database tables. Business customer creation main activity For a business customer, a main activity called SaveNewBUInformation is used to persist the data to the PA_BUSINESSUNIT table and create the corresponding MCA. The following figure shows the main activity. Similar to the ContactId for an individual customer, this main activity creates a unique id called BusinessUnitId and calls the SaveBUInformation activity of the class PegaIns-Interface-BusinessUnit. The other activities called are the same as those called in the creation of individual customer. Those are reused here as well. As with individual customer creation, the data is transformed into the interface layer from data layer as shown in the table later in this topic. Pega Underwriting for Insurance Implementation Guide 4-66

144 The following figure shows the SaveBUInformation activity: The following table shows the interface layers, the tables associated with them, and the corresponding data layers. Interface Layer Table Data layer PegaIns-Interface-Contact PA_CONTACT PegaIns-Data-Party-Person PegaApp-Interface-Address PA_ADDRESS PegaIns-Data-Address PegaApp-Interface-Contact- CommunicationOptions PegaIns-Interface- BusinessUnit PA_COMMUNICATION_OPTIONS PA_BUSINESSUNIT Data from either Pegains-Data-Party-Person or PegaIns-Data-Party-Org-Company is passed to the interface layer (depending on whether it is a contact or Businessunit) PegaIns-Data-Party-Org-Company te: For client-specific implementations, these interface layers can be mapped to the client's external contact or business customers tables as required. Pega Underwriting for Insurance Implementation Guide 4-67

145 Update Customer Profile Customer details for both individual and business customers can be updated from MCA. The UpdateCustomerDetails local action in this menu launches a screen that is used to update the customer details. This local action is defined under the Flow-Wide Local Actions of Design tab in the ManageCustomerAccount flow of the class UpdateCustomerDetails. This flow action has a postprocessing activity called SaveCustomerAccountInformation of the class PegaIns-Work that is used for updating both individual customer and business customers. The activities that are called while creating a new contact or business unit are reused in this activity. Pega Underwriting for Insurance Implementation Guide 4-68

146 The following figure shows the SaveCustomerAccountInformation activity: Pega Underwriting for Insurance Implementation Guide 4-69

147 Creating MCA from Submission Process A customer record and its corresponding MCA work object can also be created from a submission at the Applicant Identification stage. In a submission process, a user can either select an existing customer to initiate the submission from the Existing Customers list or create a new customer. Creating a new customer calls the activity PegaIns-PAB-Work-Submission SaveCustomerInfo. This activity is specialized in the child classes so that either a business or individual customer can be created accordingly based on the submission class. For a commercial submission, the activity creates a business customer; for a personal submission such as personal auto or life, the activity creates an individual customer. This activity is specialized in the following classes: PegaIns-PAB-Work-Submission-Package-Pers PegaIns-PAB-Work-Submission-Com PegaIns-PAB-Work-Submission-Package-Com te: It is important to note that in PUI versions prior to 6.3, a new MCA work object was created for each customer service interaction. That resulted in the creation of multiple new work objects for the same customer and consequently, inconsistencies in the customer management. Starting in PUI 7.1, only one MCA is created per customer. The resulting MCA is a long running object that provides a unified view of the customer. Pega Underwriting for Insurance Implementation Guide 4-70

148 Agency and Agent Management (AAM) Landing Page Similar to managing a customer account (MCA), there is a process in PUI to manage agencies and agents. Using this process, agents and agencies are searched, created, linked with each other, and updated. Agency and Agent Management (AAM) is available as a landing page in PUI by selecting Designer Studio > Framework Management > Tools > Agent/Agency Management. This is different from MCA, which is managed from the Case Manager Portal. The following figure shows the screen that appears when a user clicks the Agent/Agency Management landing page. From this screen, agencies and agents can be searched for and created independently. Pega Underwriting for Insurance Implementation Guide 4-71

149 Agent Search and Configuration When a user searches for an agent, the D_AgentList data page gets initialized, and then populates the data as a list based on the search criteria. The following figure shows an example of the agent search results screen. When a user clicks the Last Name or First Name link in the search results, a window opens up in which agent information can be updated, as shown below: Pega Underwriting for Insurance Implementation Guide 4-72

150 The following figure shows the D_AgentList data page: The object type definition of this data page is PegaIns-Data-Party-Person-Agent, which is used in the context of agent specific data. This data page is sourced by the GetListOfAgents report definition called of the class PegaIns-Interface-Agent. This class is mapped to the IIF_Agent table in the PegaDATA database. This table contains all the agent-specific information that is persisted. Every agent is identified with a unique key named AgentId. This table also has an AgencyCode column that links an agent with the agency they belongs to. This data page accepts the following parameters to fetch the list of agents from the IIF_Agent table in the database, and then populate the data as the pxresults() pagelist of the class PegaIns-Data- Party-Person-Agent: The agent data that the interface layer fetches from the database table is mapped back to the data layer (i.e., PegaIns-Data-Party-Person-Agent) using a response data transform named AgentListMapper of the class Code-pega-List. Pega Underwriting for Insurance Implementation Guide 4-73

151 The following figure shows the clipboard structure: Agency Search and Configuration An agency search works similarly. The D_AgencyList data page gets initialized and then populates the data. Pega Underwriting for Insurance Implementation Guide 4-74

152 When the Agency Name is expanded, you can view all of the agents linked to this agency as shown in the figure below. A user can update agent data by double-clicking the agent name in the list. A user can also update agent data from the agent search as shown below. Pega Underwriting for Insurance Implementation Guide 4-75

153 When a user clicks the Agency Name link in the search results, a window opens so that the user can update agency data, as shown below. The following figure shows the D_AgencyList data page: Pega Underwriting for Insurance Implementation Guide 4-76

154 The object type definition of this agency data page is PegaIns-Data-Party-Org-Agency. This is used in the context of agency specific data. This data page is sourced by the report definition GetListOfAgencies of the class PegaIns-Interface-Agency. This class is mapped to the IIF_Agency table in the PegaDATA database. This is the table in which all of the agency specific information is persisted. Every agency is identified with a unique key named AgencyCode. This data page accepts the following parameters to fetch the list of agencies from the IIF_Agency table in the database and then populate the data as the pxresults() pagelist of the class PegaIns-Data-Party-Org-Agency: The agency data that the interface layer fetches from the database table is mapped back to the data layer (i.e., PegaIns-Data-Party-Org-Agency) using the AgencyListMapper response data transform of the class Code-pega-List. The following figure shows the clipboard structure: Pega Underwriting for Insurance Implementation Guide 4-77

155 Create Agent and Agency Configuration Create Agent On the Agent/Agency Management screen, there are two buttons that enable you to create an agent or agency: Create Agent and Create Agency. The following figure shows the agent intake screen that collects agent details and persists in the IIF_Agent database table when a user clicks Create. This screen collects agent details such as personal information, the agency to which the agent belongs, and the agent license information. The following figure shows the Collect agent information dialog: The IntakeAgentDetails flow action of the class PegaIns-Data-Party-Person-Agent has a SaveAgentInformationWrapper post processing activity of the class PegaIns-Data-Party- Person-Agent, which calls the SaveAgentInformation activity of the class PegaIns-Interface- Agent, which processes the Agent information and saves it in the IIF_Agent database table (mapped to the PegaIns-Interface-Agent class). Pega Underwriting for Insurance Implementation Guide 4-78

156 The following figure shows the flow action: The above Wrapper activity first sets the MyTempPage data layer of the class PegaIns-Data- Party-Person-Agent and then passes this as a parameter to the SaveAgentInformation activity. The agent data is first set in MyTempPage and then transformed to the interface layer (PegaIns- Interface-Agent) to be saved in the database table. The following figure shows the clipboard structure; MyTempPage is the data layer: Pega Underwriting for Insurance Implementation Guide 4-79

157 The clipboard page PageToBePersisted is the interface layer that is saved in the database table after transformation from the previously mentioned data layer. The SaveAgentInformation activity generates a unique AgentId if creating a new agent or sets the existing Agentid if updating an existing agent from the Agent search results. The data transformation from the data layer to the interface layer is performed by the RenormalizeAgentDetails data transform rule of the class PegaIns-Interface-Agent. Once the data is transformed to the interface layer, it is persisted in the database by the Obj-Save method. Pega Underwriting for Insurance Implementation Guide 4-80

158 The following figure shows this activity: te: While saving Agent information, the licensed LOBs information is saved as a AgentLOBList pagelist of the class PegaIns-Data-AgencyLOB. While retrieving from the database to update an existing agent, this list is fetched as Code-Pega-List via the D_AgentLOBList data page. Pega Underwriting for Insurance Implementation Guide 4-81

159 Create Agency Similarly, the IntakeAgencyDetails flow action of the class PegaIns-Data-Party-Org-Agency invokes the SaveAgencyInformationWrapper post processing activity of the class PegaIns-Data- Party-Org-Agency. This wrapper activity then calls the SaveAgencyInformation activity of the class PegaIns-Interface-Agency. This activity, as in the agent creation activity, creates an agencycode while creating the new agency and also renormalizes the data from the data layer to the interface layer. Similar to the agent case, the following agency activities are also used when updating an existing agency. Agency data layer: PegaIns-Data-Party-Org-Agency Agency interface layer: PegaIns-Interface-Agency The following figure shows the SaveAgencyInformation activity: Pega Underwriting for Insurance Implementation Guide 4-82

160 te: Unlike MCA, agency or agent creation does not create any long running work object. It just persists the data to and retrieves the data from the agent and agency database tables. Another difference is that MCA is managed from Case Manager Portal and agent/agency management is managed from a dedicated landing page on DesignerStudio menu. te: For site-specific implementations, these interface classes can be mapped to the clientspecific external database tables. Configuring Products: Using Product Builder Core te: See the PBI 7.15 Implementation Guide for information about this topic. Pega Underwriting for Insurance Implementation Guide 4-83

161 5 Extending PUI PUI is not intended to be extended or built on. It is expected that customers will build on the specific market segment towers of Personal Lines (PL), Individual Life and Annuity (ILA), Commercial Lines (CL), or Group Underwriting (GUW). When building on a market segment layer, do not include cases from the built-on application (PUI) as this can result in duplicate classes. When you run the wizard to build your new application, if you duplicate classes exist after the case selection step, then you might need to remove a selected case from one of the built-on applications. By default, the wizard selects only the cases in your top-most application. Running the New Application Wizard When starting a new project, use the New Application Wizard to create the initial layers needed to extend the framework. In the following instructions, we use Personal Lines as the example for extending the framework. To extend the PUI PL 7.13 framework: 1. Create an operator that you will use to create the new application. You can create this ID by making a copy of the existing PUIPLSysAdmin operator ID. Alternatively, if you already have an operator ID configured, update that ID to include the access group that is used by the PUIPLSysAdmin operator ID. 2. Log in using the new operator ID. 3. Select Application menu > New Application. The Application menu is located in the Header of the developer portal (i.e., Designer Studio). 4. Click the Create new Application button. 5. Enter your application name and description, and then select Pega Underwriting For PL Insurance as the built on application. te: Because of the importance of the data on this screen and the advanced settings screen, you should work with your LSA to ensure that you configure the starting class structure correctly. 6. In the Application Structure field, select whether to build a Framework and Implementation layer or just a Framework layer. (The example that appears later in this section shows a Framework and Implementation layer). Your selection will vary based on the project. Pega Underwriting for Insurance Implementation Guide 5-1

162 7. Enter your Organization name. 8. Click Configure advanced settings. Pega Underwriting for Insurance Implementation Guide 5-2

163 The LSA should review the advanced settings to ensure that you create the correct layers for your application. 9. Double check all of the advanced settings. You can update the division and unit as well as the class structure for the implementation layer. If creating an implementation layer, create the correct structure by selecting the Generate reusable division records and Generate reusable unit records check boxes if applicable. 10. Click Save or Cancel to close the Advanced Configuration screen, and return to the Application Settings screen. Pega Underwriting for Insurance Implementation Guide 5-3

164 11. Click Next and then review the business objectives. Update the business objectives for your specific application. 12. Click Next and then review the case types. The following figure shows an example of the Case Types screen: te: If building on Pega Underwriting for Insurance in an environment with one of the market segments, be sure to clear duplicate cases from this case types list. Pega Underwriting for Insurance Implementation Guide 5-4

165 13. Depending on your application, choose which case types you need to extend to your layers. 14. Click Next and then review the data objects. Keep the data objects to add the data objects to your application rule so it will be easy to find these data classes in the Data Explorer. te: This step does not copy these classes to your layer. 15. Click Preview to review the components of the new application. 16. Click Create. The creation process takes some time. Afterwards, you can log into your new application using the PUIPLSysAdmin or operator created in step 1 above. Extending an Existing LOB As you start your project, you might need to extend the existing LOBs to include more data attributes, change a process, and so on. You will want to start to specialize the data classes into your layer at this point because many of the processes are built on data classes. The following example describes how to update some of the screens in the Personal Auto submission. 1. Create data classes in your layer for the Auto application data class, vehicle data class, and insurance policy class. (This example is updating the vehicle entry screen). a. Create an XYZ-Data-Application class that has directed inheritance to PegaIns-Data- Application. (XYZ should be replaced by your framework class; for example, EIns-FW- QuoteExpFW) b. Create an XYZ-Data-Application-Pers class and an XYZ-Data-Application-Pers-Auto class. c. Create an XYZ-Data-PolCmp-InsuredVehicle (inherit from PegaIns-Data-PolCmp- InsuredVehicle). d. Create an XYZ-Data-InsurancePolicy-Personal-Auto (inherit from PegaIns-Data- InsurancePolicy-Personal-Automotive). te that the steps above basically create a mirrored data class structure in your layer. 2. Create the property.policydata in your XYZ-Data-Application-Pers-Auto class to point to your new policy class. You can do this by copying the existing PolicyData property from the PegaIns-Data-Application-Pers-Auto class. 3. Create the property.applicationpage in your XYZ-Work-Submission-Pers-Auto class to point to your XYZ-Data-Application-Pers-Auto. 4. Create a CoveredVehicles property in your framework data class to point to your new vehicle class. te: If you change the class of a risk in PBI, then you need to update that risk to point to the new data class. Pega Underwriting for Insurance Implementation Guide 5-5

166 5. Update the ApplicationClassForComm Map Value to point to the new Application data class. Once you run the submission, the clipboard shows the.applicationpage pointing to your data class. 6. Update the section called CoveredVehicles and move it to your vehicle data class (in your layer). Then, change the screen, add new properties, and so on. You will see these changes when you invoke your submission process. Creating a New LOB This use case describes how to create a brand new LOB that is not already in the framework. To start, determine which of the framework s lines of business will be your starting point. 1. Select the Add a case type command from the Case Designer (select this command from the drop-down arrow at the top of the screen as shown below). Pega Underwriting for Insurance Implementation Guide 5-6

167 2. This example shown below adds a new LOB called Renters Insurance. The Parent auto complete field is used when you want to add this as a child to an existing case type (you can do that manually later). Make sure you set up the Derives From information correctly, and also make sure you select the Create Starting Process check box. 3. This will create the class and case type rule with some default stages. You can delete the case type rule and copy a case type rule from another LOB to get a more robust starting point. Some of the processes may not save so you can delete those from your stages. For example, you can copy the pydefault case type rule from PegaIns-PAB-Work-Submission- Pers-Auto to EIns-FW-QuoteExpFW-Work-Submission-Pers-Renters class. 4. When copying from an existing case type, do not change the label right away as that will change the identifier. Instead, select Save As and then change the label after the rule is created. 5. Add the newly created case type rule to the Application rule, and select the Create Starting Process check box if you want this case to be available from Create menu. 6. Copy the pydefault data transform from a PUI submission class to your new case type class. Pega Underwriting for Insurance Implementation Guide 5-7

168 te: The When rules IsPersonal and IsCommercial are used in the PUI process to check for the.lob name. If you change the.lob, make sure you update those When rules. Pega Underwriting for Insurance Implementation Guide 5-8

169 7. Update the DetermineLOBKey map value by setting your class name on the left side and mapping to the PBI LOB name. 8. Create a new product line in PBI and build out a quick product for testing. This example copied the Personal Umbrella Product Line. This example created a new product and included Flood Coverage. 9. Add the new LOB to an agent so that they have the right licenses to process the submission. a. Add the new LOB value to the LineOfBusiness property of class PegaIns-Data- AgencyLOB and PegaIns-Interface-AgencyLOB. b. Go to the Agent Management landing page and add a license to an agent for this LOB. Pega Underwriting for Insurance Implementation Guide 5-9