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.
| Model | Speed (ms) | [email protected] | Segmentation accuracy | Notes |
|---|---|---|---|---|
| YOLOv8-seg | 150–300 | 0.72 | 0.68 | Best speed-accuracy balance |
| Mask R-CNN | 400–800 | 0.75 | 0.71 | Higher accuracy, but twice as slow |
| RT-DETR | 200–400 | 0.70 | — | Transformer, no segmentation |
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.
| Stage | Duration | Result |
|---|---|---|
| Requirements analysis and data collection | 1–2 weeks | Spec, client dataset or demo image collection |
| Model training | 2–4 weeks | YOLOv8-seg with ≥90% accuracy on validation |
| Mobile SDK development | 3–6 weeks | iOS/Android modules with guided photo flow and antifraud |
| Backend integration | 1–2 weeks | REST API, TorchServe inference, caching |
| Testing and debugging | 2–3 weeks | Tests on real devices, usability studies |
| App store publishing | 1 week | App Store Connect, Google Play Console, TestFlight |
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.