Pricing Configuration

Overview

The pricing configuration module in timveroOS enables financial institutions to define dynamic pricing algorithms that automatically calculate loan terms and conditions based on customer profiles, product parameters, and business rules. The system supports multiple programming languages and provides testing capabilities to ensure accuracy before deployment.

Offer Engine Architecture

The Offer Engine serves as the core pricing calculation component, processing customer data and product parameters to generate customized loan offers.

Pricing algorithm configuration interface

Key Components

Algorithm Scripts: Define pricing logic using:

• JavaScript (recommended for most use cases)

• Python

• SpEL (Spring Expression Language) - for simple expressions

Input Variables: Access to:

• Customer profile attributes

• Product specifications

• Additive parameters

• Market reference data

Output Structure: Generate:

• Interest rates

• Loan amounts

• Term options

• Fee calculations

Configuration Process

Accessing the Offer Engine

Navigate to pricing configuration through:

1. Settings → Offer Engine Description

2. Settings → Credit Products → [Select Product] → Additives

3. During additive creation process

Creating Pricing Algorithms

The system provides a script editor where you can:

1. Define Base Logic

   • Set foundational pricing rules

   • Establish minimum/maximum boundaries

   • Configure profitability thresholds

2. Add Risk Adjustments

   • Credit score-based modifications

   • Debt-to-income considerations

   • Employment stability factors

3. Include Business Rules

   • Relationship pricing discounts

   • Promotional rate periods

   • Volume-based adjustments

Variables examples

Note: There is no variable autocomplete feature in the script editor. Refer to this documentation and SDK reference for available variable names. Variable names depend on your specific SDK implementation.

Customer Profile Variables (example names - verify with your SDK):

• creditScore - Credit bureau score

• monthlyIncome - Verified income

• debtToIncome - Calculated DTI ratio

• employmentMonths - Employment duration

• existingCustomer - Relationship flag

Product Variables (example names - verify with your SDK):

• requestedAmount - Loan amount

• requestedTerm - Desired duration

• productType - Product category

• additiveCode - Specific variant

Calculation Variables (example names - verify with your SDK):

• baseRate - Starting interest rate

• riskPremium - Risk adjustment

• relationshipDiscount - Customer benefits

Script Examples

JavaScript Example

JavaScript is the recommended language for most pricing algorithms due to its flexibility and ease of debugging.

// Pricing algorithm for personal loan
function calculateOffer(application, product, additive) {
    // Base rate from product configuration
    let baseRate = product.baseInterestRate;
    
    // Risk adjustment based on credit score
    let creditScore = application.participant.creditScore;
    let riskPremium = 0;
    
    if (creditScore >= 750) {
        riskPremium = -0.5; // Discount for excellent credit
    } else if (creditScore >= 700) {
        riskPremium = 0;
    } else if (creditScore >= 650) {
        riskPremium = 1.0;
    } else {
        riskPremium = 2.5;
    }
    
    // Calculate final rate
    let finalRate = baseRate + riskPremium;
    
    // Apply relationship discount for existing customers
    if (application.participant.existingCustomer) {
        finalRate = finalRate - 0.25;
    }
    
    // Ensure rate stays within product boundaries
    finalRate = Math.max(product.minRate, Math.min(product.maxRate, finalRate));
    
    return {
        interestRate: finalRate,
        maxAmount: calculateMaxAmount(application, product),
        minTerm: product.minTerm,
        maxTerm: product.maxTerm
    };
}

function calculateMaxAmount(application, product) {
    let monthlyIncome = application.participant.monthlyIncome;
    let maxDTI = product.maxDebtToIncome;
    let existingDebt = application.participant.existingMonthlyDebt;
    
    let availableForPayment = (monthlyIncome * maxDTI) - existingDebt;
    // Simplified max amount calculation
    return Math.min(availableForPayment * 36, product.maxAmount);
}

Python Example

Python can be used for more complex calculations or when integrating with external data sources.

# Pricing algorithm for auto loan
def calculate_offer(application, product, additive):
    # Get base parameters
    base_rate = product.base_interest_rate
    vehicle_value = application.collateral.value
    loan_amount = application.requested_amount
    
    # Calculate LTV ratio
    ltv = loan_amount / vehicle_value if vehicle_value > 0 else 1.0
    
    # LTV-based risk adjustment
    if ltv <= 0.7:
        ltv_adjustment = -0.25
    elif ltv <= 0.85:
        ltv_adjustment = 0
    elif ltv <= 1.0:
        ltv_adjustment = 0.5
    else:
        ltv_adjustment = 1.5
    
    # Vehicle age adjustment
    vehicle_age = application.collateral.age_years
    age_adjustment = min(vehicle_age * 0.1, 1.0)  # Max 1% for old vehicles
    
    # Calculate final rate
    final_rate = base_rate + ltv_adjustment + age_adjustment
    
    # Apply boundaries
    final_rate = max(product.min_rate, min(product.max_rate, final_rate))
    
    return {
        'interest_rate': final_rate,
        'max_amount': min(vehicle_value * 0.9, product.max_amount),
        'required_down_payment': max(0, loan_amount - (vehicle_value * 0.9))
    }

SpEL Example (Simple Expressions)

SpEL (Spring Expression Language) is suitable for simple conditional expressions.

// Simple rate selection based on credit score tier
creditScore >= 750 ? baseRate - 0.5 : (creditScore >= 700 ? baseRate : baseRate + 1.0)

Note: For complex pricing logic, use JavaScript or Python instead of SpEL.

Script Development Process

Follow this process when creating or modifying pricing algorithms:

Step 1: Define Requirements

1. Document all pricing factors to consider

2. Identify input variables needed

3. Specify output values required

4. Define boundary conditions and limits

Step 2: Develop Script

1. Navigate to Settings → Offer Engine Description

2. Select or create the pricing algorithm

3. Choose scripting language (JavaScript recommended)

4. Write the algorithm logic

5. Add comments for maintainability

Step 3: Test Thoroughly

1. Use the built-in Test function

2. Test with multiple participant profiles

3. Verify boundary conditions

4. Check edge cases (zero values, missing data)

5. Validate against expected business outcomes

Step 4: Deploy

1. Save the algorithm

2. Associate with appropriate products/additives

3. Monitor initial production behavior

4. Document the implementation

Script Error Handling

When scripts fail, the system provides error feedback:

Syntax Errors: Script contains invalid code

• Check console output for line numbers

• Verify bracket matching and semicolons

• Review variable names for typos

Runtime Errors: Script fails during execution

• Check for null/undefined values

• Verify data types match expectations

• Add defensive checks for optional fields

Business Logic Errors: Script produces invalid results

• Review calculation formulas

• Verify boundary conditions

• Check comparison operators

Example: Defensive Coding

// Always check for null/undefined values
let creditScore = application.participant.creditScore || 0;
let monthlyIncome = application.participant.monthlyIncome || 0;

// Validate before calculations
if (monthlyIncome <= 0) {
    return { error: 'Invalid income value' };
}

Testing and Validation

Test Interface

Before deploying pricing algorithms, use the built-in testing tool:

1. Select Test Parameters

   • Choose product

   • Select additive

   • Pick test participant

2. Run Test Scenario

   • Click "Test" button

   • System executes algorithm

   • View generated offer

3. Validate Results

   • Check calculated rates

   • Verify amount limits

   • Confirm term options

   • Review fee structure

Error Handling

Common test failures and solutions:

Script Errors:

• Syntax errors in code

• Missing variable references

• Logical inconsistencies

Data Issues:

• Missing profile attributes

• Invalid data types

• Out-of-range values

Business Rule Violations:

• Below profitability threshold

• Outside product parameters

• Regulatory compliance issues

Deal Block Integration

The pricing engine integrates with the Deal Block to present offers to customers:

Dynamic product availability based on customer profile

Offer Presentation Flow

1. Product Eligibility

   • System evaluates all products

   • Pricing engine calculates offers

   • Available products displayed

2. Conditional Availability

   • Products requiring collateral highlighted

   • Missing requirements indicated

   • Dynamic recalculation upon changes

Calculated terms and conditions display

1. Offer Details

   • Interest rate presentation

   • Payment schedule preview

   • Total cost disclosure

Complete offer presentation

Preliminary payment schedule

Pricing Strategies

Risk-Based Pricing

Configure algorithms to adjust rates based on risk factors:

• Credit score tiers

• Income verification levels

• Collateral coverage ratios

• Payment history patterns

Relationship Pricing

Implement benefits for existing customers:

• Multi-product discounts

• Loyalty rate reductions

• Payment history rewards

• Referral incentives

Market-Based Adjustments

Include market conditions in pricing:

• Reference rate integration

• Competitive positioning

• Portfolio composition goals

• Seasonal adjustments

Integration with Other Modules

Product Configuration

Pricing algorithms connect to:

• Product parameters for boundaries

• Additive settings for specific rules

• Documentation requirements

• Workflow triggers

Workflow Management

Pricing outcomes influence:

• Approval thresholds

• Documentation requirements

• Collateral specifications

• Processing paths

Reporting and Analytics

Track pricing effectiveness through:

• Offer acceptance rates

• Portfolio yield analysis

• Competitive positioning

• Profitability metrics

Best Practices

Algorithm Design

• Start with simple logic and add complexity gradually

• Comment code thoroughly for maintenance

• Use consistent variable naming conventions

• Build in error handling for edge cases

Testing Protocol

• Test with representative customer profiles

• Include boundary conditions

• Verify regulatory compliance

• Document test scenarios and results

Performance Optimization

• Minimize complex calculations

• Cache frequently used values

• Optimize database queries

• Monitor execution times

Maintenance

• Regular review of pricing effectiveness

• Update algorithms based on performance

• Maintain version history

• Document all changes

Common Use Cases

Personal Loans

• Simple interest rate calculations

• Risk-based pricing tiers

• Term-dependent rates

• Fee structures

Auto Loans

• LTV-based adjustments

• Vehicle age considerations

• Down payment requirements

• Insurance factors

Mortgage Products

• Complex rate structures

• Multiple adjustment factors

• Regulatory compliance

• Long-term considerations

Troubleshooting

No Offers Generated

• Check algorithm logic

• Verify test data completeness

• Review profitability settings

• Examine product parameters

Incorrect Calculations

• Debug algorithm step-by-step

• Verify variable values

• Check mathematical operations

• Review business rules

Performance Issues

• Simplify complex calculations

• Optimize data retrieval

• Review algorithm efficiency

• Consider caching strategies

Next Steps

With pricing configured, proceed to:

• Collateral Management - Configure security requirements

• Workflow Fundamentals - Build approval processes

• Loan Tracking (OPS) - Set up portfolio management

---

For additional pricing configuration support, consult your implementation team or system documentation.