Overview
The BriteCore platform is a SaaS solution with services built to drive business operations through a fully–managed insurance platform. The platform is a single tenant system—a dedicated deployment environment instance per tenant, with no sharing of data or computing resources except for a small set of infrastructural elements and backend scripts (monitoring, scheduled jobs, and configurations).
BriteCore comprises a set of RESTful services that enable specific modules that are deployed as serverless lambda functions. Each BriteCore service endpoint is associated with a respective lambda function—modules developed in Python.
This document outlines a high-level description of the BriteCore data models within each of the main modules.
Lines
BriteCore Lines allows insurers to model the fields, rates, rules, and forms associated with the insurance products. Lines may be inherited from templates and versioned by date and jurisdiction.
Line of business
The line of business (LOB) describes a product or set of related products that make up a particular insurance offering. It represents a "type” of insurance. LOBs are the highest hierarchical entity in a Lines configuration.
Examples of LOBs
- Homeowners - Personal
- Private Passenger Auto - Personal
- Farmowners - Personal
- Standard Fire & EC - Personal
- Long Haul Truckers - Commercial
- Commercial Liability - Commercial
- Cargo - Commercial
- Cyber Liability - Commercial
Lines data model
Figure 1 illustrates a high-level overview of the Lines data model.
Lines uses a core data structures organized in the following manner:
- Line-of-Business
- Policy Type/Product
- Policy/Risk
- Line Items
- Fields
- Rates
- Forms
Data is defined in the LOB and later feeds into all other modules within BriteCore such as Quotes, Policies, Claims, Reports, and Docs.
Product
Product describes a particular insurance offering within a LOB. For example, the product HO-Commons can be defined under Homeowners.
Versioning
Line, risk type, and all entities of risk type are bound to a version. A version is composed of a name and an effective date. The effective date tells when a certain LOB, risk type, or entity is going live/is effective from.
Once a LOB or risk type is live, users shouldn't be able to make changes to it. Instead, users will create a new version with a new effective date and make changes there.
Risk Type
Risk Type refers to a types of risk that gets insured. Different LOBs target different risks. Lines offers risk templates for real-world entities. For example:
- Auto: Driver, vehicle.
- Property: Home, homeowner, swimming pool, shed.
A risk type models the fields, rate tables, calculations, and line items that follow a particular type of risk. Lines are parents of risk types.
Line Item data model
Figure 2 provides a high-level overview of the line item data model.
Line Items are parents of:
- Fields: Describe facts about a risk or pieces of data needed to collect about the risk.
- Rates: Rating calculates the premium and fees due on a policy.
- Calculations: Advanced tool to rate risks.
- Coverages: Insures an exposure against a peril. For example:
- Collision: Personal Auto coverage that insures property damaged during a collision.
Quotes
Quotes and Policies work together to handle different processes of the policy lifecycle.
You can’t instantiate quotes without a LOB definition in Lines. Lines includes a rating engine, which is a service that evaluates field answers and items (coverages) on a quote or policy and provides a premium.
Lines defines all of the data points that will be captured and evaluated during a quote, so it’s important to understand the structure of the LOB before working on building a quoting front end.
The quoting front end won’t interact with Lines directly. Instead, the quoting front end will submit requests to Quotes, which will communicate with Lines to create new quotes for a given line and new risks from a given risk group.
Policies data model
Policies interacts with other products in BriteCore such as Lines, Quotes, Rules, and Docs to allow you to:
- View policy information, including contacts, insurable risk, coverages, limits, and premiums.
- View policy transaction history, including when, what, and by whom.
- Compare transactions; you can view what was changed and the previous endorsement.
Figure 7 illustrates the Policies data model.
A revision is the foundation of a policy and tracks the changes made to a policy over time, including written premium. The following revision states indicate whether the revision’s information is in effect:
- Committed: The data associated with the revision is in effect and can be reported on.
- Open: The data associated with the revision is in progress and, therefore, isn’t in effect and can’t be reported on.
- Pending: The data associated with the revision is in progress and, therefore, isn’t in effect and can’t be reported on.
- Archived: The data associated with the revision was at one time in effect and can be reported on.
Claims
Claims enables organizations to manage the full life cycle of property and casualty (P&C) insurance claims from FNOL to settlement.
Figure 9 illustrates the Claims data model.
Claims model
The Claims system connects to Lines through the data hierarchy and will inherit from Lines product and coverage information unique to a line of business. When the FNOL is created and a policy selected, the claims system will know which LOB product configurations (LOB/State) from Lines to apply to the claim based on the policy effective date and date of loss.
The Lines product information will tell the claim system:
- Screens that will be presented for the LOB and coverages.
- Values displayed in drop down lists on these screens (Reference Table configuration).
- Coverages that can be claimed against.
- Reserve and payment categories that will be available for each coverage.
- Correspondence that will be made available.
- Rules that will be applied.
Product configuration and changes are managed in Lines and will be pulled into Claims to minimize configuration in Claims for the support of new product versions. Claims takes a feed from any product configured in Lines. If the client publishes a new version of a product, Claims can be configured to recognize that version and can manage unique data elements that may come from that version.