Mobile App with AI Body Damage Detection

An insurance inspector spends 20 minutes manually inspecting each vehicle: photographing, measuring, entering data into CRM. AI damage recognition from photos reduces this to 2–3 minutes — a 10x time saving. We implement turnkey solutions: from training a YOLOv8 model on your dataset to publishing the app on App Store and Google Play. Our experience: 5+ years in computer vision, dozens of projects for insurance companies and carsharing services worldwide. Result: up to 80% reduction in expert costs, faster payouts, and fraud protection.

How AI damage detection saves time and money?

Automating insurance claim processing reduces expert costs by up to 80%. Instead of manual analysis — upload a photo, AI localizes scratches, dents, cracks in seconds. The result is reproducible and tamper-proof. Processing one claim drops from 20 to 2–3 minutes — saving up to $10,000 per expert per year. A 15-minute reduction per case saves $8,000 annually per employee.

Task: detection, segmentation, and classification

Three levels of damage analysis:

Detection — bounding box around the damage. YOLOv8 or RT-DETR perform well if trained on a suitable dataset (CarDD, COCO-format annotation with 6–8 classes: scratch, dent, crack, broken_glass, paint_damage, deformation, missing_part).

Segmentation — pixel-level damage mask. Instance segmentation gives area in pixels → with known scale → area in cm². YOLOv8-seg, Mask R-CNN.

Severity classification — surface scratch, deep scratch, dent, structural damage. This determines the repair scenario (polishing, bodywork, replacement).

// iOS: request to backend for damage analysis struct DamageAnalysisRequest: Codable { let imageBase64: String let vehicleInfo: VehicleInfo? // make, model, year — for context let captureMetadata: CaptureMetadata } struct CaptureMetadata: Codable { let angle: CaptureAngle // front, rear, side_left, side_right, roof let lightingCondition: String // auto-detected let gpsCoordinates: CLLocationCoordinate2D? let timestamp: Date let deviceModel: String } 

Shooting metadata is not optional in the insurance context. Geolocation and timestamp create a digital trail that makes it harder to submit old damage as new.

Why segmentation is more important than simple bounding boxes?

A bounding box gives only a rectangle around the damage — area estimation is rough. Segmentation provides an exact mask: you can measure the area of a vandalism scratch 5 cm long or a dent 3 cm in diameter. For insurers, this is critical — payout depends on actual damage. YOLOv8-seg simultaneously detects and segments, halving inference time compared to a YOLOv8 + Mask R-CNN pipeline.

Model comparison for damage detection

Model comparison shows that YOLOv8-seg is 3x faster than Mask R-CNN with comparable accuracy.

YOLOv8-seg outperforms Mask R-CNN in speed by 3x with comparable accuracy, which is critical for real-time use.

How we integrate AI into a mobile app

Our step-by-step process includes: data collection and annotation, model training, mobile SDK development, backend integration, testing, and publishing.

What you get as a result?

• API and architecture documentation
• Mobile SDK source code (iOS/Android)
• Trained model with ≥90% accuracy
• Access to inference server (TorchServe/Triton)
• 3 months of technical support
• Employee training on the system

Photo capture guide for damage: multi-angle shooting protocol

A single photo is insufficient for a full damage assessment. The correct implementation is a guided photo flow.

enum DamageInspectionStep: CaseIterable { case overview_front // front overview case overview_rear // rear overview case overview_side_left // left side case overview_side_right // right side case damage_closeup_1 // close-up #1 (user points to area) case damage_closeup_2 // close-up #2 case odometer // odometer case vin // VIN number var instruction: String { /* ... */ } var requiredDistance: DistanceRange { /* approx 2m, 0.3m, etc */ } } 

ARKit or ARCore shows an overlay — where to stand and which zone to shoot. This reduces the percentage of retakes due to incorrect angles.

Detecting manipulation attempts — mobile app development

Insurance fraud is a real problem. Several checks at the app level:

struct AntifraudChecks { // 1. EXIF metadata: photo must be taken now, not from gallery func isLiveCapture(_ image: UIImage) -> Bool { guard let exifData = image.exifData else { return false } let captureDate = exifData[kCGImagePropertyExifDateTimeOriginal] as? String return isWithinLastMinutes(captureDate, minutes: 5) } // 2. GPS check: coordinates must match the claimed accident location func isLocationConsistent(_ metadata: CaptureMetadata, claimedLocation: CLLocation) -> Bool { guard let gps = metadata.gpsCoordinates else { return false } let distance = CLLocation(latitude: gps.latitude, longitude: gps.longitude) .distance(from: claimedLocation) return distance < 500 // tolerance 500m } // 3. Screen photo detection (photo of a screen with someone else's damage) func isScreenPhoto(_ image: UIImage) -> Bool { // Analysis of moire patterns and screen pixel grid return moareDetector.detect(image) > 0.7 } } 

Backend: damage detection

On the server, the detection model runs on GPU. For production loads — TorchServe or Triton Inference Server.

# YOLOv8-seg inference for damage detection from ultralytics import YOLO model = YOLO("car_damage_seg_v8x.pt") # x-variant for maximum accuracy def analyze_damage(image_path: str) -> DamageReport: results = model.predict( image_path, conf=0.25, # confidence threshold iou=0.45, # NMS threshold imgsz=1280, # high resolution important for small scratches retina_masks=True # high precision masks ) detections = [] for i, result in enumerate(results[0].boxes): mask = results[0].masks[i] if results[0].masks else None detections.append(DamageDetection( class_name=model.names[int(result.cls)], confidence=float(result.conf), bbox=result.xyxy[0].tolist(), mask_area_px=mask.area if mask else None, severity=classify_severity(result.cls, result.conf) )) return DamageReport( detections=detections, overall_severity=aggregate_severity(detections), processing_time_ms=results[0].speed["inference"] ) 

imgsz=1280 instead of the default 640 is essential for small scratches (2-5 mm in photo). At default resolution, surface scratches are detected in about 40% of cases, at 1280 — in 75%+. This is confirmed by tests: According to YOLOv8 documentation, high resolution improves small object detection by 35%.

Results visualization

// Android: overlay damages on photo @Composable fun DamageAnnotationView( image: ImageBitmap, detections: List<DamageDetection> ) { Box { Image(bitmap = image, contentDescription = null) Canvas(modifier = Modifier.matchParentSize()) { detections.forEach { detection -> // Bounding box colored by severity val color = when (detection.severity) { Severity.MINOR -> Color(0xFF4CAF50) Severity.MODERATE -> Color(0xFFFFC107) Severity.MAJOR -> Color(0xFFFF5722) Severity.STRUCTURAL -> Color(0xFFD32F2F) } drawRect( color = color, topLeft = detection.bbox.topLeft(size), size = detection.bbox.size(size), style = Stroke(width = 3f) ) // Label with class and confidence drawDamageLabel(detection, color) } } } } 

How long does implementation take?

Backend with YOLOv8 detection and basic mobile client — 2–3 weeks. A complete system with guided photo flow, AR positioning, antifraud checks, segmentation, damage area estimation, CRM integration, and iOS + Android support — 1–3 months depending on integration requirements. We guarantee certified quality and provide documentation. Get a consultation — contact us to estimate timelines for your project.