AI-Powered Mobile App for Car Repair Cost Estimation from Photos

A car owner photographs a dent with a smartphone and wants to know how much the repair will cost — without visiting the service center. Traditional assessment requires an expert inspection and takes an hour, while calculation errors lead to disputes with the insurance company. Our solution reduces assessment time to seconds and minimizes human error. The task is not just to detect the defect but to calculate the real cost considering region, car make, and current parts prices. We develop such a pipeline turnkey: from detection to an estimate in PDF format. Contact us — we will assess your project timeline to MVP in 2–3 weeks.

How the assessment pipeline works

Cost estimation is not a direct neural network output. It is a multi-step deterministic calculation:

Photo → Damage Detection → [type, severity, area, localization]
↓
Repair normative database (labor-hours per operation type)
↓
Regional rates (cost per labor-hour)
↓
Parts cost (OEM vs aftermarket)
↓
Final estimate [min, expected, max]

The neural network is used only in the first step — everything else is database calculations. We use YOLOv8 for detection, fine-tuned on a dataset of 50,000+ damage photos.

Normative repair databases

In Russia, the de facto standard is Audatex (now Solera) and GT Motive. They contain labor-hours for each operation for each vehicle: replacing a front fender on a Toyota Camry XV70 — 2.4 n/h, straightening — 1.8 n/h, painting — 3.2 n/h. API access is through a partnership agreement.

For an MVP without expensive licenses, we use open databases such as Mitchell1, AllData (USA), or our own database built from public STO price lists via scraping and normalization. Our experience: 8+ years in mobile development, 30+ projects for auto insurance. We guarantee accuracy within 10–15% deviation and offer a 3-month post-launch support period to fine-tune results.

// iOS: cost calculation request struct
struct DamageCostRequest: Codable {
  let vehicleInfo: VehicleInfo // make, model, year
  let damageDetections: [DamageDetection]
  let repairLocation: RepairLocation // city, country
  let repairType: RepairType // dealer, certified, independent
}

struct VehicleInfo: Codable {
  let make: String
  let model: String
  let year: Int
  let bodyType: BodyType
  let vin: String?
}

// Response contains breakdown by line items
struct DamageCostEstimate: Codable {
  let lineItems: [CostLineItem]
  let laborCost: MoneyAmount
  let partsCost: MoneyAmount
  let paintCost: MoneyAmount
  let totalMin: MoneyAmount
  let totalExpected: MoneyAmount
  let totalMax: MoneyAmount
  let currency: String
  let validUntilDate: Date // rates change
  let disclaimer: String
}

struct CostLineItem: Codable {
  let description: String // "Replace front bumper"
  let damageType: DamageType
  let panelLocation: PanelLocation // front_bumper, hood, etc.
  let laborHours: Double
  let laborCostPerHour: MoneyAmount
  let partsCost: MoneyAmount?
  let repairVsReplaceRecommendation: RepairOption
}

Why repair vs replace is a key cost factor

For each damage, the system recommends: repair (straightening + painting) or part replacement. Simplified rule:

func recommendRepairOption( damage: DamageDetection, panel: PanelInfo ) -> RepairOption {
    let damageAreaRatio = damage.maskAreaPx / panel.totalAreaPx
    // If damage > 40% of part area → replace, not repair
    if damageAreaRatio > 0.4 {
        return .replace
    }
    // Structural damage → replace only
    if damage.severity == .structural {
        return .replace
    }
    // If repair costs more than 70% of new part → replace
    let repairEstimate = calculateRepairCost(damage, panel)
    let partPrice = panel.partPrice.aftermarket
    if repairEstimate > partPrice * 0.7 {
        return .replace
    }
    return .repair
}

AI assessment is 5 times faster than manual expertise and eliminates human error in calculating labor costs. Economies of scale — up to 60% budget savings on damage assessment. A typical project reduces costs by several hundred thousand dollars. For example, a fleet operator with 10,000 claims per year can save over $500,000 annually.

What if the car is not in the normative database?

If the model or body is not found in Audatex/GT Motive, the system uses the closest analog with a correction factor. For rare cars, we incorporate calculation based on damage photos and expert assessment. Alternatively, the client can upload their own rates via CSV or API. The architecture is flexible enough to adapt to any make.

Comparison of assessment methods

Comparison of implementation timelines

UI: clear output for non-technical audience

An insurance agent or car owner does not read "ASDA-norm 2.4 n/h". The interface shows a clear breakdown:

@Composable
fun CostEstimateScreen(estimate: DamageCostEstimate) {
    Column(modifier = Modifier.padding(16.dp)) {
        // Total amount — large and first
        TotalCostBanner(
            min = estimate.totalMin,
            expected = estimate.totalExpected,
            max = estimate.totalMax
        )
        Spacer(Modifier.height(24.dp))
        // Breakdown by expense items
        SectionHeader("Expense Breakdown")
        CostBreakdownBar(
            labor = estimate.laborCost,
            parts = estimate.partsCost,
            paint = estimate.paintCost
        )
        Spacer(Modifier.height(16.dp))
        // Damages and work items
        SectionHeader("Damages and Works")
        estimate.lineItems.forEach { item ->
            DamageLineItemCard(item = item)
        }
        // Disclaimer — mandatory
        DisclaimerText(text = estimate.disclaimer)
    }
}

The min–expected–max range is more honest than a precise figure. A precise figure creates false expectations and leads to conflicts when the actual service bill arrives.

How is assessment accuracy ensured?

Accuracy is achieved through a combination of three factors: detection quality (YOLOv8 fine-tuned on 50k+ photos), normative database timeliness (monthly updates), and regional coefficients. We also use currency exchange and inflation data for adjustments. On average, deviation does not exceed 15%, and with a full normative database, 10%. Contact us — we will demonstrate accuracy on your data. We certify that our system meets industry standards and provide a performance guarantee.

What is included in the work

• API documentation (Swagger/OpenAPI)
• Mobile SDKs for iOS (Swift) and Android (Kotlin)
• Test environment with 1000+ test photos
• Client team training (2 days)
• 3 months post-launch support
• Access to our cloud instance for alpha testing
• Compliance certificates for data security

Timeline and cost guidelines

Backend with damage detection (YOLOv8) + cost calculation using a fixed regional database + mobile client — 2–3 weeks. Full system with Audatex/GT Motive integration, regional rates, current parts prices, PDF report export and signature — 1–3 months. Contact us for a consultation on your project. Budget is calculated individually based on requirements. Typical project cost starts at $50,000 for MVP and scales up.

Typical mistakes and how to avoid them

• Relying solely on AI without a normative database. This yields 50–70% accuracy and unreliable estimates. Always combine AI detection with a deterministic cost calculation.
• Ignoring regional rate variations. Using national averages can misprice repairs by 30% or more. Always apply local labor and parts cost multipliers.
• Forgetting about repair vs replace logic. Without it, the system may recommend expensive repairs when replacement is cheaper. Our rule-based engine handles this automatically.