RISC Scoring Guide

Understanding the Risk Intelligence Scoring Capability (RISC) system.

What is RISC?

RISC (Risk Intelligence Scoring Capability) is DeepV's proprietary field-level risk assessment system that provides comprehensive quality validation across every field in an appraisal document. The RISC system ensures data integrity through systematic field-by-field validation and risk scoring.

Core Principles

Inverted Scoring Model

CRITICAL: RISC uses an inverted scoring system where LOWER scores are BETTER.

0 = Perfect/Best - No issues detected
100 = Worst/Critical - Severe issues requiring immediate attention

Score Scale

0 to 100

Black Ball Exception

Black (⚫) - Field not yet reviewed or marked for special handling

The Six Risk Balls

🟢 Green Ball (0-19) - Low Risk
🔵 Blue Ball (20-39) - Mild Risk
🟡 Yellow Ball (40-59) - Moderate Risk
🟠 Orange Ball (60-79) - High Risk
🔴 Red Ball (80-100) - Critical Risk
⚫ Black Ball - Not Reviewed

Field Validation Requirements

Every Field Must Be Validated

Every field gets a risk ball - Each field in the appraisal receives a risk score and corresponding colored ball
Every field must be marked reviewed - No field can remain with a black ball; all must be explicitly reviewed and validated

Validation Workflow


Field Extracted → Black Ball (⚫)
AI Analysis → Risk Score Assigned (0-100)
Risk Ball Color → Colored Ball (🟢🔵🟡🟠🔴)
Human Review → Marked as Reviewed
Approval → Only when all fields reviewed



Using RISC Scores

Basic Implementation

typescript
interface RISCScore {
  fieldId: string;
  score: number;        // 0-100 (lower is better)
  level: 'low' | 'mild' | 'moderate' | 'high' | 'critical';
  color: string;        // Risk ball color
  reviewed: boolean;    // Has been marked reviewed
  issues: string[];     // Specific issues detected
}

// Example field with RISC score
const fieldScore: RISCScore = {
  fieldId: 'FID_1234_ADDRESS',
  score: 15,           // Low risk (Green)
  level: 'low',
  color: '#10b981',
  reviewed: true,
  issues: []
};



Decision Logic

typescript
function canApprove(fields: RISCScore[]): boolean {
  // Rule 1: All fields must be reviewed
  const allReviewed = fields.every(f => f.reviewed);
  if (!allReviewed) {
    return false;
  }

  // Rule 2: No critical risk fields
  const hasCritical = fields.some(f => f.score >= 80);
  if (hasCritical) {
    return false;
  }

  // Rule 3: Limited high risk fields
  const highRiskCount = fields.filter(f => f.score >= 60).length;
  if (highRiskCount > 5) {
    return false;
  }

  return true;
}



Aggregate Scoring

typescript
function calculateAggregateRISC(fields: RISCScore[]): number {
  // Weighted average: higher risk fields count more
  const weights = fields.map(f => {
    if (f.score >= 80) return 5;      // Critical: 5x weight
    if (f.score >= 60) return 3;      // High: 3x weight
    if (f.score >= 40) return 2;      // Moderate: 2x weight
    return 1;                          // Low/Mild: 1x weight
  });

  const weightedSum = fields.reduce((sum, f, i) =>
    sum + (f.score * weights[i]), 0
  );

  const totalWeight = weights.reduce((sum, w) => sum + w, 0);

  return Math.round(weightedSum / totalWeight);
}



Risk Distribution Analysis

Tracking Field Distribution

typescript
interface RiskDistribution {
  low: number;        // 0-19 (Green)
  mild: number;       // 20-39 (Blue)
  moderate: number;   // 40-59 (Yellow)
  high: number;       // 60-79 (Orange)
  critical: number;   // 80-100 (Red)
  unreviewed: number; // Black balls
}

function analyzeDistribution(fields: RISCScore[]): RiskDistribution {
  return {
    low: fields.filter(f => f.score < 20).length,
    mild: fields.filter(f => f.score >= 20 && f.score < 40).length,
    moderate: fields.filter(f => f.score >= 40 && f.score < 60).length,
    high: fields.filter(f => f.score >= 60 && f.score < 80).length,
    critical: fields.filter(f => f.score >= 80).length,
    unreviewed: fields.filter(f => !f.reviewed).length
  };
}



Quality Metrics

typescript
function calculateQualityMetrics(distribution: RiskDistribution) {
  const total = distribution.low + distribution.mild +
                distribution.moderate + distribution.high +
                distribution.critical;

  return {
    // Percentage of fields with low/mild risk
    qualityRate: ((distribution.low + distribution.mild) / total) * 100,

    // Percentage of fields needing attention
    actionRate: ((distribution.moderate + distribution.high +
                  distribution.critical) / total) * 100,

    // Critical issue rate
    criticalRate: (distribution.critical / total) * 100,

    // Review completion rate
    reviewRate: ((total - distribution.unreviewed) / (total + distribution.unreviewed)) * 100
  };
}



Trend Analysis

Tracking Score Changes

typescript
interface RISCTrend {
  improving: boolean;   // Score decreasing (getting better)
  declining: boolean;   // Score increasing (getting worse)
  stable: boolean;      // No significant change
  changeAmount: number; // Absolute change in score
}

function analyzeTrend(
  currentScore: number,
  previousScore: number
): RISCTrend {
  const change = currentScore - previousScore;
  const threshold = 5; // 5-point change threshold

  return {
    improving: change <= -threshold,
    declining: change >= threshold,
    stable: Math.abs(change) < threshold,
    changeAmount: Math.abs(change)
  };
}



Visualization Examples

typescript
// Trend indicator component
function TrendIndicator({ trend }: { trend: RISCTrend }) {
  if (trend.improving) {
    return ;
  }
  if (trend.declining) {
    return ;
  }
  return ;
}



Best Practices

DO

Review all fields - Mark every field as reviewed before approval
Prioritize high scores - Address fields with scores above 60 first
Monitor trends - Track whether scores are improving or declining
Document issues - Maintain clear records of what caused high scores
Use field-level detail - Don't rely solely on aggregate scores
Validate black balls - Ensure no unreviewed fields remain

DON'T

Approve with black balls - Never approve while fields remain unreviewed
Ignore moderate risk - Yellow balls (40-59) need attention too
Confuse score direction - Remember: LOW scores are GOOD
Skip critical fields - Red balls (80-100) must be resolved
Overlook patterns - Multiple yellow balls may indicate systemic issues
Rush reviews - Proper field validation takes time

Advanced Strategies

Risk Threshold Customization

typescript
interface RiskThresholds {
  approveMax: number;      // Maximum aggregate score for auto-approve
  reviewMin: number;       // Minimum score requiring review
  criticalFields: number;  // Max allowed critical risk fields
  highFields: number;      // Max allowed high risk fields
}

const strictThresholds: RiskThresholds = {
  approveMax: 20,    // Only low risk allowed
  reviewMin: 40,     // Review anything moderate+
  criticalFields: 0, // No critical fields allowed
  highFields: 2      // Max 2 high risk fields
};

const standardThresholds: RiskThresholds = {
  approveMax: 35,
  reviewMin: 60,
  criticalFields: 0,
  highFields: 5
};



Field Priority Weighting

typescript
interface FieldWeight {
  fieldId: string;
  weight: number; // 1-10, where 10 is most critical
}

const criticalFields: FieldWeight[] = [
  { fieldId: 'FID_ADDRESS', weight: 10 },
  { fieldId: 'FID_SALE_PRICE', weight: 10 },
  { fieldId: 'FID_APPRAISED_VALUE', weight: 10 },
  { fieldId: 'FID_LEGAL_DESC', weight: 8 },
  { fieldId: 'FID_ZONING', weight: 6 }
];

function calculateWeightedRisk(
  scores: RISCScore[],
  weights: FieldWeight[]
): number {
  const weightedScores = scores.map(score => {
    const weight = weights.find(w => w.fieldId === score.fieldId)?.weight || 1;
    return score.score * weight;
  });

  const totalWeight = scores.reduce((sum, score) => {
    return sum + (weights.find(w => w.fieldId === score.fieldId)?.weight || 1);
  }, 0);

  return Math.round(
    weightedScores.reduce((sum, s) => sum + s, 0) / totalWeight
  );
}



Integration Examples

Real-time Validation

typescript
async function validateField(
  fieldId: string,
  value: string
): Promise {
  const response = await fetch('/api/risc/validate', {
    method: 'POST',
    body: JSON.stringify({ fieldId, value })
  });

  const score: RISCScore = await response.json();
  return score;
}

// Use in form validation
const fieldScore = await validateField('FID_1234', formData.value);
if (fieldScore.score > 60) {
  showWarning(

);
}



Batch Processing

typescript
async function validateAppraisal(
  fields: Array<{ id: string; value: string }>
): Promise {
  const scores = await Promise.all(
    fields.map(f => validateField(f.id, f.value))
  );

  const distribution = analyzeDistribution(scores);
  const metrics = calculateQualityMetrics(distribution);

  return {
    scores,
    distribution,
    metrics,
    canApprove: canApprove(scores)
  };
}



Monitoring and Reporting

Dashboard Metrics

Track these key performance indicators:

Average RISC Score - Should be trending down (improving)
Review Completion Rate - Should be 100% before approval
Critical Field Rate - Percentage with scores >= 80
Quality Distribution - Breakdown by risk level
Time to Resolution - How long to resolve high-risk fields

Alerting Rules

typescript
interface Alert {
  severity: 'info' | 'warning' | 'critical';
  message: string;
}

function generateAlerts(scores: RISCScore[]): Alert[] {
  const alerts: Alert[] = [];

  // Critical: Any unreviewed fields
  if (scores.some(s => !s.reviewed)) {
    alerts.push({
      severity: 'critical',
      message: 'Unreviewed fields detected - approval blocked'
    });
  }

  // Critical: Any critical risk fields
  const critical = scores.filter(s => s.score >= 80);
  if (critical.length > 0) {
    alerts.push({
      severity: 'critical',
      message:


    });
  }

  // Warning: High risk fields
  const high = scores.filter(s => s.score >= 60 && s.score < 80);
  if (high.length > 5) {
    alerts.push({
      severity: 'warning',
      message:


    });
  }

  return alerts;
}

Conclusion

0-100 scale: Lower scores = better quality
Six risk balls: 🟢 🔵 🟡 🟠 🔴 ⚫
Every field validated: No black balls remain
Risk-based decisions: Use scores to prioritize review and approval

Next Steps

Best Practices
Integration Guide
REST API Reference