Idle Scooter Sharing App: Local AI Resolves Scratch Disputes

A Father's Observation, a Student's Open-Source Experiment

"These cars just sit here every day until 6 PM. Someone should be making money off this." This casual remark from the father of developer Raga Vinjanampati, standing in an office building parking lot, unexpectedly sparked an interesting open-source project.

In India, millions of students and office workers park their scooters, motorcycles, or cars at their company or school every morning at 9 AM and don't use them again until evening. That means every vehicle sits completely idle for at least 9 hours a day. And just a few streets away, there's always someone who needs transportation for exactly those hours—to go to an interview, visit a hospital, or attend class.

Raga decided to turn this obvious side-hustle opportunity into reality: rent out the time when vehicles are "sleeping." But within five minutes she hit the real problem—not the booking flow, but trust.

Vehicle owner: "There's a new scratch on the side." Renter: "That was already there."

Every rental ended with this argument. No one could prove anything, so no one trusted anyone. And ultimately, no one wanted to rent.

The Idea

IdleWheels: Three Steps to Complete Shared Rental

The IdleWheels that Raga built allows neighbors to rent each other's idle scooters, bicycles, and cars by the hour. The entire process is compressed into three steps:

Step 1: List idle time. Vehicle owners add vehicle information, location, and available time slots (e.g., 9:30 AM to 5:30 PM). If they don't know how to price it, they can tap "✨ Ask Gemma" and the AI will suggest a reasonable hourly rate.

Step 2: Book and communicate. Renters select a date and time window and send a request. The app displays the total price upfront (e.g., 7 hours × 35 rupees = 245 rupees). Until the owner accepts, both parties' phone numbers remain hidden; after acceptance, a chat window opens within the booking to coordinate pickup.

Step 3: Handover inspection (the core part). Take 4 photos at pickup (front, left, right, rear) and the same 4 photos at return. Then, Gemma 3—an open-weight AI model running on the owner's own laptop—compares each pair of photos and lists only new damage, with severity and confidence levels. The verdict goes directly into the booking chat, and both parties can save the full report as a PDF.

That's the entire dispute resolution process. No arguments, just two sets of photos and an impartial "second pair of eyes."

Let AI Judge, Don't Let It Do Math

For the pricing feature, Raga's first version was straightforward: show the vehicle photo to Gemma and have it output an hourly price. The result was that for three similar scooters, Gemma quoted 95 rupees, 180 rupees, and 600 rupees respectively.

"600 rupees an hour? That price should come with a driver and a cup of chai."

Small models perform poorly at math and consistency. So she split the task into two parts:

Gemma does what it's good at: observing the vehicle and classifying it as economy, standard, or premium.
A rate table handles the calculation: She researched real self-drive rental prices in Hyderabad this month (Royal Brothers, Zoomcar, Revv, etc.) and set IdleWheels pricing slightly below market rate. A neighbor's scooter doesn't come with corporate backing, insurance packages, or roadside assistance, so it shouldn't charge the same.

This led to the most valuable lesson from the entire project:

Let AI judge, but don't let it do arithmetic.

Small models (like 4B parameters) have inherent limitations in mathematical reasoning and numerical consistency. Large language models are essentially generating text based on probability, not performing precise calculations, so directly asking a model to output numbers like prices or quantities can easily produce fluctuations or even absurd results. Common mitigation strategies include: breaking numerical tasks into classification + lookup tables, using external calculation tools, or prompting the model to output structured JSON for post-processing by the program. IdleWheels' approach—letting Gemma classify vehicle tiers, then having a rate table calculate the price—is exactly about separating the model's semantic understanding capability from deterministic computation, avoiding the unreliability of small models in arithmetic.

How Local AI Ensures Privacy and Lowers the Barrier

Why must handover inspection run locally? Because handover photos are private. They may capture license plates, the owner's home, or even faces.

In IdleWheels, these photos go directly from the browser to the owner's own laptop and nowhere else. The server only receives text verdicts, such as "new scratch on left panel, minor."

Comparison	IdleWheels (Local Gemma)	Paid Cloud Vision API
Where photos go	Owner's own laptop	Someone else's server
Cost per handover inspection	0 rupees	Charged per image, 8 images per inspection
Rental shop with 50 handovers/day	Still 0 rupees	Bill grows every day
Want more accurate detection	Switch to gemma3:12b or fine-tune	Wait for vendor updates

A side hustle depends on thin margins. A rental earning 245 rupees per order can't afford to pay API call fees for every handover. An open-source model running on the owner's existing laptop makes the trust layer free.

Open-weight models refer to models whose parameter weights are released under public licenses after training, allowing anyone to download, run locally, modify, or even fine-tune them. Unlike closed-source models accessible only via API (such as GPT-4, Claude), open-weight models like Gemma, Llama, and Mistral can be fully deployed offline on users' own hardware. This brings three key advantages: data never leaves the device, satisfying privacy requirements; no per-call billing, zero marginal cost; and users can freely choose model scale (e.g., 4B, 12B) or perform domain-specific fine-tuning. IdleWheels leverages exactly this feature, running Gemma 3 4B via Ollama on the owner's laptop, making photo comparison completely local.

Technical Implementation: A Minimal Stack with No Build Step

The entire app uses pure HTML, CSS, and JavaScript, with no build step. A tiny Node.js server (with just one dependency: pg) stores listings, bookings, and chats in Render Postgres. AI never runs on the server.

📱 Browser ──4+4 photos──▶ 💻 Owner's laptop
                        (Ollama + Gemma 3 4B)
📱 Browser ◀──JSON verdict── 💻
📱 Browser ──plain text─────▶ ☁️ Render
                        (Node + Postgres:
                         listings, bookings, chats)

Getting a small 4B model to honestly compare two photos is the real work:

Describe first, then judge. Each request sends pickup and return photos together, using a JSON schema to force Gemma to describe photo 1, then photo 2, and only then list changes. Ollama fills fields in order, so the verdict is based on what the model just saw, not guesswork.
Tell it what to ignore. Two photos taken hours apart can never be identical—lighting changes, shadows move, reflections shift. The prompt instructs Gemma to ignore all of these, as well as dust.
Allow it to say "unsure." Gemma can answer unsure and flag when the two photos aren't from the same angle. A dispute tool that fabricates damage is worse than no tool at all.

Ollama is an open-source local large model runtime that simplifies downloading, running, and managing open-weight models on personal computers. Users can launch a model with a single command (like ollama run gemma3:4b) and interact with it through a local API (default port 11434). Ollama supports structured output (JSON schema), which can force the model to generate responses in a specified field order—this is exactly the key to IdleWheels' "describe first, then judge" approach. Additionally, Ollama is compatible with macOS, Linux, and Windows, with relatively friendly hardware requirements—4B models can run smoothly on ordinary laptops.

Honest Limitations: This Is Not a Product Ready for Commercialization

At the end of the article, Raga candidly listed the project's boundaries:

A 4B model on a laptop may miss hairline scratches and can be fooled by glare. It's a second pair of eyes, not a judge.
Identity verification is currently just a name, a phone number, and a key stored in the browser. A real launch would need OTP verification.
Legal issues: In India, using privately registered (white plate) vehicles for paid rentals requires commercial registration and insurance. IdleWheels is a demonstration of the trust layer. The fastest realistic path to deployment is licensed rental shops—they experience the exact same scratch arguments every day.

Why Open-Source Innovation Matters Here

Raga's project is an entry in the Hacktoberfest Open Source AI Challenge. It demonstrates the unique value of local open-source models in real side-hustle scenarios: privacy-sensitive data never leaves the device, marginal cost is zero, and models can be freely upgraded as needed.

For small rental shops handling dozens of vehicle handovers daily, a free inspection tool running on an existing laptop may be more practical than any cloud API. And the lesson "let AI judge, don't let it do math" applies to all developers trying to fit small models into business workflows.

The project is live on Render, with code hosted on GitHub, including a complete static demo version. If you've ever lost the "that scratch was already there" argument, this project at least offers a technical solution that doesn't take sides.