The claims platform that runs itself, and knows when to stop.
RepairCheck moves a car damage claim from a photo to a priced estimate with nobody in the middle. Events dispatch the nearest expert, who takes the job with one tap and books the visit in a chat thread already open on their phone. Behind it sits a copilot that writes what it finds straight into the record, and stops itself at the calls only a human makes. We designed and built all of it.
From photo to finished report.
Three steps, run in order at the car. Scroll to step through them.
The whole car, the same way every time.
The app guides the expert around the vehicle shot by shot and records a spoken note for each area. Nothing missed, and it works offline when the garage has no signal.
OpenAI reads the damage. The expert signs off.
A vision pass flags the dents and scratches and the panel each sits on. The AI proposes and a human confirms every line before it counts.
A finished PDF, on the desk instantly.
The confirmed findings become a structured report the customer and insurer both open, synced to the cloud the moment it is done.
Nobody dispatches the case. The case dispatches itself.
Every row that lands on a case timeline fires an event. A router reads its type and fans it out. Dispatch resolves a postcode against 10,813 indexed coordinates, ranks the nearest experts by real distance, and sends an invitation, never a forced assignment. Germany is a ninety nine region grid, matched in a single hop before the radius ever widens.
Region first, in one hop. The radius only widens if it has to.
It waits. Nothing moves until the expert taps accept.
The six hour visit reminder is not a job sweeping a table. It is a key, expiring.
It reads, prices, and sends. Then it gets out of the way.
A photo enters a fixed route: what is this, which way is the car facing, what is damaged. The findings write themselves to the case. A cost estimate reaches the customer without a single person reviewing it. The moment a real appraiser claims the case, the automatic estimate switches itself off. The machine defers to the professional, never the other way round.
A photo enters the route.
Is this a vehicle or a document?
vehicleWhich way is the car facing?
front leftWhich panel, and how bad?
front left damageA priced estimate reaches the customer. Nobody reviewed it.
The model reads. It does not decide the route.
A real appraiser claims the case
The automatic estimate switches itself off.
Tags are additive
Findings attach to the case. Nothing already there gets removed.
Empty fields only
Extracted values fill blanks. A value a person typed is never overwritten.
The off switch
Automatic estimates stop the moment a professional claims the case. The system defers, and it does it in code, not in policy.
The best interface is the one already open.
Case invitations arrive as a message with two buttons. One tap takes the job. The whole site visit gets booked in plain sentences: no form, no fields, no app to install. Text, voice notes, photos and button taps all land on the case timeline the moment they arrive.
Eight things the system needs. Zero forms.
The invitation is a message, not a notification. Two buttons, one tap, no login.
The tap writes straight to the case timeline. The expert never opened an app.
Free text, not a form. The system reads a sentence and fills eight fields.
State lives in memory between messages, so the conversation survives a gap.
Text, voice notes, photos and button taps all land on the same timeline.
One surface of it is an app.
The platform hands the case to a person, and this is what that person holds. Built with React Native and Expo, tuned to feel native on iOS, and built to work where the car actually is.
Neuer Fall · RC-2481
Aufnahme
RC-2481 · KI-Analyse
Schäden
RC-2481
Bericht
Bericht fertig
Als PDF · synchronisiert
It works where there is no signal
Cases start in car parks and on hard shoulders. Everything captures on the device and uploads the moment it reconnects, so nothing is lost between the car and the office. The expert never waits for a bar of reception to do their job.
What it was built on
One React Native codebase on the phone, a NestJS platform behind it, and three separate engines doing the thinking.
It can change everything. It just never gets the last word.
The copilot works a case the way an expert does. It reads the photos, prices the damage, and writes what it finds straight into the record, and none of that waits for a click. Two things stop it. Evidence it cannot stand behind, meaning a blurred photo, damage that was already there, or a story the pictures do not support. And the last step out the door, because nothing reaches a customer and nothing becomes final until a person signs it. The instinct is to assume a model can be talked into a number. This one reads the panel closer than the person holding the camera.
It works the case alone
It reads and it writes, neither of which needs a person. Damage, fields, contacts, tyres and notes all get updated on its own authority. A copilot that needs a click per line is just a form with extra steps.
It stops when the evidence does
It flags these instead of guessing at them. People assume a model can be talked into a number, and it is the wrong way round: it reads the panel closer than the person holding the camera, and staged damage is the thing it is best at seeing.
- photo too blurred to priceconfidence < 0.60
- damage that predates the claimstaged / pre-existing
- pictures that contradict the noteevidence conflict
- estimate over the sign-off linevalue threshold
The last step is yours
Everything reversible, it does. Everything that leaves the building or cannot be taken back waits for a person: the message to the customer, the number the insurer pays, the status that closes the case.
- send_emailreaches the customer
- update_case_statuscloses the case
- delete_attachmentcannot be undone
- estimate.outputthe number the insurer pays
- case.ownershipwho the case belongs to
Every one of those numbers is a decision someone had to make on purpose. Letting it write was the easy half. The interesting engineering is knowing the five things it should never finish alone.
Every appraisal, one flow.
One pipeline carries the full RepairCheck catalogue, from a liability claim on a Tuesday morning to a classic-car valuation. Each type has its own rules, its own evidence, and its own report, and the system knows which is which.
Rated 5.0 by the people who use it.
Real, public Google reviews of the RepairCheck service the app runs on.
“The whole thing was fast and absolutely professional. I was kept informed at every step, and it was very precise. Highly recommend.”
“Extremely competent, knows the trade, and personable too. Top service, fast, first class. Thank you very much.”
Automate it. Keep the last word.
The hard part was never making software decide. It was knowing when it has to stop and hand back. Tell us the process you would hand over if it always knew where that line was, on a free 20 minute call.