NotMyDent

Rental companies have damage claims. Now renters have evidence.

Inspiration

What it does

How we built it# NotMyDent

Rental companies have damage claims. Now renters have evidence.

Inspiration

Imagine renting a car for the weekend. You return it, go home, and think everything is fine.

A few days later, you receive an email:

"We found scratches on the bumper. You owe us $500."

Wait, what? You don't remember scratching anything.

Maybe those scratches were already there. Maybe they weren't. You even recorded a walkaround video before picking up the car, but now you're scrolling through hundreds of frames, trying to find one tiny scratch.

The rental company has a close-up damage photo. You have a video from a completely different angle. How do you prove whether it's the same scratch?

It's your word against theirs, and finding the evidence is harder than it should be.

That's why we built NotMyDent.

What it does

NotMyDent turns rental car videos into visual evidence that helps renters understand and dispute damage claims.

Simply upload:

A video recorded before picking up the car.
A video recorded after returning it.
The rental company's damage photograph.
The company's description of the alleged damage.

Our system automatically finds the claimed area in both videos, compares the specific scratches or dents, and explains what changed.

It provides four possible outcomes:

PRE-EXISTING DAMAGE: The same damage was visible before the rental.

POSSIBLE NEW DAMAGE: The claimed damage appears after return but was not identifiable before.

CLAIM NOT SUPPORTED: The claimed damage isn't identifiable in either video, despite adequate visual evidence.

INCONCLUSIVE: The available footage isn't sufficient to establish what happened.

Instead of just giving a verdict, NotMyDent shows the actual frames, zoomed damage regions, timestamps, detection scores, and an explanation.

How we built it

We combined three pretrained AI models with traditional computer vision techniques.

1. Damage Detection — CarDD + YOLOv8

We use a CarDD-based YOLOv8s model to locate the scratches or dents described in the company's claim. This identifies the exact area we need to investigate.

2. Video Search — OpenAI CLIP

A walkaround video can contain thousands of frames. Instead of examining every frame with a large AI model, CLIP searches for frames showing the relevant part of the vehicle.

3. Image Alignment — SIFT + RANSAC

The company's photo might be a close-up, while the renter's video shows the entire car.

SIFT feature matching and RANSAC-based homography help us locate the corresponding physical area despite differences in camera angle and distance.

4. Visual Reasoning — Qwen3-VL-8B

This is the core of NotMyDent.

Qwen3-VL compares the specific damage through targeted image comparisons:

Company vs. AFTER: Does the alleged damage match the return footage?
AFTER vs. BEFORE: Was that same damage visible before pickup?
Company vs. BEFORE: Independently verify the claimed marks against the pickup footage.

Instead of simply asking whether scratches exist, we compare their shape, orientation, position, and surrounding vehicle features.

We run Qwen3-VL-8B with 4-bit quantization using BitsAndBytes to make inference practical on a Google Colab GPU.

5. Decision Engine & Evidence

A rule-based engine combines the visual observations into a final verdict. We use Python, PyTorch, Hugging Face Transformers, OpenCV, PyAV, and Matplotlib to process videos, generate visualizations, and return structured results for our frontend.

Challenges we ran into

The AI confidently saw scratches that weren't there.

This was our biggest challenge.

Initially, we passed the company's photo, BEFORE frame, and AFTER frame together to Qwen3-VL.

The AFTER image clearly showed scratches. The BEFORE image showed a smooth bumper.

But Qwen confidently claimed the exact same scratches were visible in BOTH videos.

It even described matching shapes and orientations.

We could literally see that its conclusion was wrong.

Our first fix was to inspect the images independently, but that created another problem: the model became too cautious, repeatedly saying the BEFORE footage was too blurry.

We realized we were asking the wrong question.

Instead of asking "Is there damage in this image?", we needed to ask:

"Are THESE SPECIFIC scratches from the company's photo visible in THIS exact location?"

We redesigned the pipeline around pairwise comparisons, showing Qwen only two sources at a time and comparing actual physical marks rather than generic damage.

This produced the expected result in our test: scratches matching the company claim appeared in AFTER but were not identifiable in BEFORE.

Finding the same car isn't finding the same damage.

Another challenge was matching a zoomed-in company photograph to a moving walkaround video.

CLIP could identify similar vehicle frames, but that didn't guarantee we were looking at the correct location.

We combined CLIP with SIFT and geometric alignment to locate the same bumper region, even when the camera perspectives were different.

Making it run on limited resources.

Our pipeline uses multiple models, including an 8B vision-language model.

We reduced memory requirements by sampling video frames, narrowing the search before visual reasoning, releasing models between stages, and running Qwen3-VL with 4-bit quantization.

Accomplishments that we're proud of

We built a working end-to-end pipeline that compares the specific damage being claimed, not just generic scratches.

The most satisfying moment was fixing the false-positive BEFORE observation and watching the system correctly distinguish a smooth bumper from one with visible scratches.

We're also proud that NotMyDent doesn't hide its reasoning behind a single verdict. Users can inspect the matched frames, timestamps, and actual visual differences themselves.

And we made the system reusable: the pipeline returns structured results and saved evidence images for integration with our web application.

What we learned

A confident AI answer isn't always a correct answer. Our earliest model gave a convincing explanation for scratches that weren't even visible.

We learned that good AI systems aren't necessarily built by giving a model more information. Sometimes, breaking a complicated question into smaller, carefully designed comparisons works much better.

We also learned that finding damage and proving it's the same damage are completely different computer vision problems.

Most importantly, we learned that AI should support evidence, not replace it.

The goal isn't to automatically blame the renter or the company. It's to help people see what actually happened.

What's next for NotMyDent

We want to complete our frontend and API integration, generate downloadable dispute reports, and improve reliability by analyzing multiple neighboring video frames instead of relying on one selected view.

We also plan to test more vehicles, lighting conditions, damage types, and camera angles to measure how reliably the system identifies matching marks.

Eventually, the same approach could help with apartment deposits, equipment rentals, and other situations where people get charged for damage they may not have caused.

Because you shouldn't need to be a computer vision engineer to dispute a scratch on a rental car.

Built With

Python · PyTorch · Qwen3-VL-8B · CarDD · YOLOv8 · OpenAI CLIP · SIFT · RANSAC · OpenCV · Hugging Face Transformers · Accelerate · BitsAndBytes · Ultralytics · PyAV · NumPy · Pillow · Matplotlib · Google Colab

They have a damage claim. You have the footage. NotMyDent connects the dots.