Skip to main content
A quote is a tariff proposal that provides pricing and coverage details to a prospective customer before a policy is issued. It represents the insurer’s offer to provide coverage under specific terms and conditions, including the premium amount, coverage period, and applicable rules. Quotes are essential in the insurance sales process, allowing customers to understand the cost and terms before committing to purchase.

​
Quote Definition

​
Quote Configuration

Quotes are configured by defining three interconnected elements that determine both coverage scope and pricing: 1. Coverage Tiers Coverage tiers define different levels of protection offered by the insurance product. Each tier represents a distinct coverage package with its own set of included perils, coverage limits, and benefits. The platform allows the creation of custom-named tiers with no limit on the number of tiers that can be configured for a product. Tiers are typically structured in ascending order of comprehensiveness, with each higher tier providing broader protection at a correspondingly higher premium. 2. Perils Perils are the specific risks covered by the insurance policy, such as fire, theft, water damage, or liability. Each coverage tier includes a defined set of perils that determine what events are covered under that tier. The relationship between tiers and perils is fundamental: higher tiers include more perils or provide enhanced coverage for the same perils compared to lower tiers. 3. Excess Levels The excess (or deductible) is the amount the customer must pay out of pocket before insurance coverage applies when making a claim. Each tier can be configured with multiple excess options, allowing customers to choose their preferred balance between premium cost and out-of-pocket risk. Higher excess amounts result in lower premiums, while lower excess amounts increase premiums.

​
Pricing Engine Integration

The platform supports two distinct approaches for calculating quote premiums, providing flexibility to accommodate different insurance company requirements and technical architectures. Internal Pricing Engine The pricing engine can be integrated directly into the Korint API, with all rating logic and calculation rules configured within the platform. In this approach, the product configuration defines the pricing formulas, rating factors, tier structures, and component calculations. When a quote is requested, the platform’s internal engine processes the customer and asset data according to these configured rules and generates the premium calculation entirely within the system. This approach offers several advantages: quote generation is fast because no external calls are required, the pricing logic is fully transparent and auditable within the platform, and the configuration can be updated without coordinating with external systems. It works particularly well for products with straightforward rating structures or when the insurance company wants centralized control over pricing rules. External API Integration Alternatively, the platform can call external APIs provided by the insurance company to compute premiums. In this model, Korint sends the customer and asset information to the insurer’s pricing system via API, and the external system performs the rating calculation and returns the base premium components. The platform then receives these prices and recomputes them within the Korint API to adapt the pricing based on the selected coverage tier, policy duration, and payment frequency. This ensures that the final quote reflects all product-specific configurations while leveraging the insurer’s core pricing logic. This approach is valuable when the insurance company has existing, sophisticated pricing systems that they want to continue using, when rating logic is highly complex or proprietary and must remain within the insurer’s infrastructure, or when the insurer needs to maintain pricing control independently of the platform. The external API integration ensures that Korint can work seamlessly with any insurer’s technology stack while still providing a unified user experience for brokers and customers.

​
Quote Components

Quotes are structured using components, similar to line items on an invoice. Each component represents a distinct element of the premium calculation, allowing for granular pricing transparency and flexible billing configurations. Components break down the total premium into its constituent parts, showing exactly what the customer is paying for and how each element will be billed over time. Every component in a quote has a specific type that defines its purpose. Premium components represent the base insurance coverage cost. Peril components correspond to individual risks being covered, such as theft, fire, or liability. Fee components capture administrative charges, broker commissions, or service fees. Tax components include statutory charges like Insurance Premium Tax or other regulatory levies. This structured approach ensures that every element of the premium is clearly identified and properly accounted for in billing and reconciliation. The charge type of each component determines when and how it will be billed to the customer. Recurring components are charged on every billing cycle throughout the policy period—these typically include the core premium and ongoing coverage perils. One-time components are charged only once, usually at policy inception, and might include setup fees, administrative charges, or initial processing costs. Spot components are charged at specific moments during the policy lifecycle, such as when a mid-term adjustment occurs or when a particular event triggers an additional charge. Each component contains detailed financial information including the base amount before fees and taxes, any applicable fees with their own charge types, taxes with their respective charge types, and the total amount including all fees and taxes. This comprehensive breakdown allows the system to generate accurate invoices, track revenue by component type, apply different billing schedules to different components, and provide complete transparency to customers and brokers about pricing composition.
A basic home insurance quote with straightforward pricing calculated entirely within the Korint platform using internal rating logic.Pricing Calculation Flow:When a broker requests a quote, the platform uses its internal pricing engine to calculate premiums based on configured rating rules:
  1. Customer & Asset Data Collection: The broker enters property details (location, construction type, square footage, rebuild value) and customer information (claims history, security features).
  2. Internal Rating Engine: The platform applies configured rating factors directly within the Korint API:
    • Base rate determined by property location and construction type
    • Adjustment factors applied for security features (+10% discount for alarm system)
    • Claims history modifier applied (-5% for claim-free years)
    • Administrative fee added as a percentage of base premium (10%)
    • Insurance Premium Tax calculated on total premium (12%)
  3. Component Generation: The system generates a single premium component with all fees and taxes included.
Generated Quote Configuration:
{
  id: 'HOME_INSURANCE_PREMIUM',
  type: 'PREMIUM',
  chargeType: 'RECURRING',
  premium: {
    amountPreFeesAndTaxes: 50000,  // €500.00 (base premium after all rating factors)
    fees: [
      {
        id: 'ADMIN_FEE',
        chargeType: 'RECURRING',
        amount: 5000  // €50.00 (10% of base premium)
      }
    ],
    taxes: [
      {
        id: 'INSURANCE_TAX',
        chargeType: 'RECURRING',
        amount: 6600  // €66.00 (12% IPT on premium + fees)
      }
    ],
    totalFees: 5000,
    totalTaxes: 6600,
    amountWithFeesAndTaxes: 61600  // €616.00
  }
}
Pricing Logic:
  • Base rate: €550.00 (for property type and location)
  • Alarm system discount: -€55.00 (10%)
  • Claim-free discount: -€27.50 (5% of adjusted amount)
  • Subtotal: €467.50
  • Risk adjustment: +€32.50 (based on rebuild value)
  • Base Premium: €500.00
  • Admin fee: +€50.00 (10%)
  • Insurance tax: +€66.00 (12% of €550.00)
  • Total: €616.00
How This Will Be Billed:The customer pays €616.00 per billing period (monthly or annually depending on invoice frequency). Since all components are marked as RECURRING, the same amount is charged on every invoice throughout the policy period. If the policy has monthly billing, the customer receives 12 invoices of €616.00 each. With annual billing, they receive one invoice of €616.00 at the start of each policy year.Total Annual Cost: €616.00 × 12 months = €7,392.00Advantages of Internal Pricing:
  • Instant quote generation (no external API latency)
  • Full transparency of rating factors within the platform
  • Easy configuration updates without external system coordination
  • Complete audit trail of pricing calculations
A comprehensive motor insurance quote with multiple perils, one-time fees, and spot charges, where base premiums are calculated by the insurer’s external pricing system and then adapted by Korint based on coverage tier, policy duration, and payment frequency.Pricing Calculation Flow with External API:When a broker requests a motor insurance quote, the platform orchestrates pricing through external API integration:
  1. Customer & Asset Data Collection: The broker enters vehicle details (make, model, year, usage type, annual mileage) and driver information (age, license years, claims history, location).
  2. External API Call: Korint sends a pricing request to the insurer’s external rating system: 
    POST https://insurer-api.example.com/v1/pricing/motor

Request Payload:
{
  "vehicle": {
    "make": "Renault",
    "model": "Clio",
    "year": 2020,
    "usage": "COMMUTE",
    "annualMileage": 12000
  },
  "driver": {
    "age": 35,
    "licenseYears": 15,
    "claimsHistory": [],
    "postalCode": "75001"
  },
  "coverageLevel": "COMPREHENSIVE"
}

External API Response:
{
  "basePerils": [
    {
      "perilId": "LIABILITY",
      "annualPremium": 224520  // €2,245.20 annual
    },
    {
      "perilId": "COMPREHENSIVE",
      "annualPremium": 87204   // €872.04 annual
    }
  ],
  "riskScore": 0.72,
  "validUntil": "2025-10-16T09:40:06Z"
}
  3. Korint Adaptation Layer: The platform receives the external pricing and applies product-specific configurations:
    • Converts annual premiums to monthly amounts (÷12)
    • Applies tier-specific adjustments based on selected excess level
    • Adds configured fees (setup fee, administrative charges)
    • Calculates taxes based on jurisdiction rules
    • Assigns charge types to each component (recurring, one-time, spot)
  4. Component Generation: The system structures the final quote with all components properly typed for billing.
Generated Quote Configuration:
{
  components: [
    // Recurring Peril: Liability Coverage (from external API, adapted to monthly)
    {
      id: 'LIABILITY',
      type: 'PERIL',
      chargeType: 'RECURRING',
      premium: {
        amountPreFeesAndTaxes: 18710,  // €187.10 (€2,245.20 ÷ 12)
        fees: [{ 
          id: 'LIABILITY_FEE', 
          chargeType: 'RECURRING', 
          amount: 4678  // 25% broker commission
        }],
        taxes: [{ 
          id: 'LIABILITY_TAX', 
          chargeType: 'RECURRING', 
          amount: 2100  // 9% insurance tax
        }],
        totalFees: 4678,
        totalTaxes: 2100,
        amountWithFeesAndTaxes: 25488  // €254.88
      }
    },
    // Recurring Peril: Comprehensive Coverage (from external API, adapted to monthly)
    {
      id: 'COMPREHENSIVE',
      type: 'PERIL',
      chargeType: 'RECURRING',
      premium: {
        amountPreFeesAndTaxes: 7267,  // €72.67 (€872.04 ÷ 12)
        fees: [{ 
          id: 'COMP_FEE', 
          chargeType: 'RECURRING', 
          amount: 1817  // 25% broker commission
        }],
        taxes: [{ 
          id: 'COMP_TAX', 
          chargeType: 'RECURRING', 
          amount: 816  // 9% insurance tax
        }],
        totalFees: 1817,
        totalTaxes: 816,
        amountWithFeesAndTaxes: 9900  // €99.00
      }
    },
    // One-Time Fee: Policy Setup (configured in Korint)
    {
      id: 'SETUP_FEE',
      type: 'FEE',
      chargeType: 'ONE_TIME',
      premium: {
        amountPreFeesAndTaxes: 0,
        fees: [{ 
          id: 'SETUP_FEE', 
          chargeType: 'ONE_TIME', 
          amount: 2500  // Platform configuration
        }],
        taxes: [],
        totalFees: 2500,
        totalTaxes: 0,
        amountWithFeesAndTaxes: 2500  // €25.00
      }
    },
    // Spot Charge: Attack Tax (triggered at policy inception)
    {
      id: 'ATTACK_TAX',
      type: 'TAX',
      chargeType: 'SPOT',
      premium: {
        amountPreFeesAndTaxes: 0,
        fees: [],
        taxes: [{ 
          id: 'ATTACK_TAX', 
          chargeType: 'SPOT', 
          amount: 560  // Regulatory requirement
        }],
        totalFees: 0,
        totalTaxes: 560,
        amountWithFeesAndTaxes: 560  // €5.60
      }
    }
  ]
}
API Integration Details:
  • External System: Insurer’s proprietary rating engine calculates base peril premiums using their actuarial models
  • Korint Processing: Receives annual amounts, converts to billing frequency, applies fees and taxes per product configuration
  • Caching: External API response cached for 7 days to allow quote comparison without repeated API calls
  • Fallback: If external API unavailable, quote generation fails gracefully with clear error message to broker
How This Will Be Billed:First Invoice (Policy Inception):
  • Liability (recurring): €254.88
  • Comprehensive (recurring): €99.00
  • Setup Fee (one-time): €25.00
  • Attack Tax (spot): €5.60
  • Total First Invoice: €384.48
Subsequent Monthly Invoices (Months 2-12):
  • Liability (recurring): €254.88
  • Comprehensive (recurring): €99.00
  • Total Monthly Invoice: €353.88
Billing Explanation:The recurring components (liability and comprehensive coverage) appear on every invoice throughout the policy period. The one-time setup fee is charged only on the first invoice when the policy is created. The spot tax is also charged on the first invoice and will be charged at each renewal of the contract. Total Annual Cost: €384.48 (first month) + (€353.88 × 11 months) = €4,277.16Advantages of External API Integration:
  • Leverages insurer’s sophisticated actuarial models and proprietary rating logic
  • Maintains pricing control within insurer’s core systems
  • Allows real-time rate updates without Korint configuration changes
  • Supports complex rating factors that may be proprietary or highly specialized
  • Enables integration with existing insurer technology infrastructure
This structure allows the platform to bill different components on different schedules, providing flexibility for complex insurance products while maintaining complete transparency in pricing and billing.

​
Quote Generation

​
How Quotes Are Created

Quote generation begins after the customer and asset information has been entered into the system. The broker or customer first provides essential details about who is seeking insurance (the customer) and what needs to be insured (the asset). Once this foundational information is complete, the system can calculate pricing and generate one or more quote proposals. Once the customer selects their desired coverage tier and excess level, the quote generation process begins. The system evaluates the customer’s risk profile, the asset’s characteristics, and the selected coverage options against the product’s pricing rules. It then applies rating factors, calculates the base premium, adds applicable fees and taxes, and produces a complete quote with all components properly structured. This calculation happens automatically immediately after the tier selection, ensuring consistency and accuracy across all quotes.

​
Multiple Quote Options

For many insurance products, the platform can generate multiple quote options simultaneously, allowing customers to compare different coverage levels and pricing scenarios. Each quote option might differ in coverage limits, deductibles, optional perils included, or payment frequency. For example, a motor insurance customer might receive three quotes: a basic liability-only option at €50 per month, a standard comprehensive option at €85 per month, and a premium option with enhanced coverage at €120 per month. All quotes are calculated from the same customer and asset data but reflect different coverage configurations. The system presents these multiple quotes to the customer or broker, who can review and compare them side by side. This comparison helps customers make informed decisions about the level of protection they need versus what they can afford. The broker can explain the differences between options and guide the customer toward the most appropriate choice for their circumstances.

​
Quote Selection and Acceptance

Once the customer reviews the available quote options, they select the one that best meets their needs. This selected quote becomes the primary quote for the policy and serves as the basis for all subsequent steps in the policy issuance process. The system records which quote was chosen and locks in that pricing and coverage configuration. When the customer accepts their chosen quote, the policy moves forward into different workflows depending on the product configuration. The quote transitions to a confirmed status, and the policy can then proceed through various processes such as the signature workflow for document signing, the payment workflow for processing the initial premium, or other product-specific workflows. Once all required workflows are completed, the policy is officially issued and coverage begins. The acceptance of a quote is a critical milestone because it represents the customer’s commitment to purchase and triggers the conversion from a pricing proposal to an active insurance contract.

​
Quote Lifecycle and Status Progression

A quote progresses through a defined lifecycle from initial generation through to acceptance or invalidation. Each stage represents a specific milestone in the quote’s journey and determines what actions can be performed. The system tracks the quote status to ensure proper workflow management and maintain pricing integrity. The Complete Quote Lifecycle:
  1. Quote Generated - After the customer selects their desired coverage tier and excess level, the system calculates the pricing and generates the quote. The quote includes all premium components, fees, and taxes based on the selected configuration.
  2. Email Sent to Customer - The system automatically sends an email to the customer presenting the quote details, including the monthly premium amount they will pay, coverage summary, and policy terms. The customer can review this information to understand the financial commitment and coverage they will receive.
  3. Customer Review Period - The customer reviews the quote and decides whether to proceed. During this period, several outcomes are possible:
    • Customer accepts the quote - If the customer is satisfied with the pricing and coverage, they proceed to sign the policy documents and complete the purchase workflow
    • Customer requests changes - If the customer wants different coverage, a different tier, or a different excess level, a new devis (quote) is created with the updated configuration. The system generates a new quote reflecting the requested changes and sends another email to the customer with the revised pricing
    • Customer takes no action - If the customer does not respond within the configured validity period, the quote expires and becomes invalid
  4. Quote Expiration - Each quote has a validity period configured at the product level. If the customer does not accept the quote and sign the policy documents within this timeframe, the quote automatically expires. An expired quote cannot be used to issue a policy, and a new quote must be generated if the customer later decides to proceed.
  5. Quote Acceptance and Policy Issuance - When the customer accepts the quote, they move forward to sign the policy documents. Once the signature and any other required workflows are completed, the policy is officially issued and coverage begins.

​
Quote Expiration and Validity

Every quote includes a validity period configured at the product level, defining how long the quoted pricing remains guaranteed. This period varies by product—some allow 30 days while others may set shorter periods of 14 days or less based on market conditions and risk characteristics. If a quote expires before the customer accepts it, the system automatically invalidates it. A new quote must be generated if the customer later decides to proceed, which will be recalculated using current pricing rules and may differ from the original quote. All expired quotes are retained in the system for audit and historical reference.