DEV Community: Christian

Why I Built CartLens: An AI Receipt Scanner for Local Price Comparison

Christian — Tue, 22 Sep 2026 07:35:30 +0000

Online shopping has trained us to expect price transparency.

Before buying a laptop, pair of headphones, or household item online, we can open several tabs, compare sellers, review price history, and decide whether a deal is actually good. In a physical store, that visibility largely disappears. We see one shelf price, at one location, at one moment—and usually make a decision without knowing what nearby shoppers paid for the same product.

That gap is why I built CartLens: an AI receipt scanner for local price comparison that helps shoppers answer a deceptively simple question:

Did I overpay?

CartLens scans receipts and price tags, identifies products and prices, compares them with nearby observations, and helps shoppers find less expensive local options. The larger goal is not merely to digitize receipts. It is to turn everyday purchases into useful, privacy-conscious shopping intelligence.

The internet solved online price comparison—not physical retail

Price-tracking tools work well when product pages are public, product identifiers are consistent, and historical prices can be collected repeatedly. Physical retail is different.

Local prices may vary by:

store and neighborhood;
date and time;
package size or quantity;
promotion or loyalty status;
regional inventory;
product variant; and
whether the shelf price matches the final checkout price.

The result is what I call market darkness: the shopper can see the price directly in front of them but cannot easily see the surrounding market.

Searches such as “how to compare grocery prices between stores using receipts” or “how to find cheaper prices at stores near me” reveal the real need. People are not asking for another generic coupon feed. They want an answer based on the products they actually buy and the stores they can realistically visit.

A receipt is more than proof of purchase

A receipt is a compact record of economic activity. It may contain:

merchant and location;
purchase date and time;
product descriptions;
quantities and unit prices;
discounts and taxes; and
the final amount paid.

Individually, that data helps one shopper understand one transaction. Aggregated carefully and stripped of personal information, receipts can form a local price map grounded in completed purchases.

This is the core idea behind CartLens: real receipts from real shoppers can reveal the prices people actually paid in nearby stores.

That distinction matters. A listed online price may differ from an in-store price. A promotion may have expired. A delivery marketplace may include a markup. A shelf label may not reflect the final checkout total. Receipt-derived data gives the system evidence of a completed transaction.

How AI receipt scanning works

At first glance, receipt scanning looks like a standard optical character recognition problem: take an image and extract text. In practice, reliable receipt analysis is a pipeline.

1. Capture and image preparation

The system first has to deal with real-world photography: tilted paper, shadows, crumpled receipts, faded thermal printing, glare, long receipts, and cluttered backgrounds.

Image preprocessing can improve contrast, correct perspective, identify the receipt boundary, and divide long documents into manageable regions. Better input produces better OCR, but the system must still assume imperfect images.

2. OCR and layout understanding

Extracting characters is only the beginning. The application must distinguish a product line from a subtotal, tax, loyalty message, payment reference, or return policy.

Layout carries meaning. A price positioned at the far right of a product description is different from a number inside a promotion code. Receipt formats also vary by retailer, region, language, and point-of-sale system.

3. Product normalization

Retail receipts frequently use abbreviations that make sense to a store's database but not to a shopper—or another store's catalog. The same item might appear under several shortened descriptions.

CartLens therefore has to move from raw OCR text toward a normalized product identity. That can involve:

text cleanup;
brand and product extraction;
barcode, UPC, or PLU matching when available;
package-size detection;
category classification;
semantic similarity; and
confidence scoring.

The challenge is not simply recognizing words. It is deciding whether two messy descriptions refer to the same product, a comparable product, or different products entirely.

4. Unit-price normalization

A lower sticker price does not always mean a better deal. A 12-ounce package and a 20-ounce package cannot be compared honestly without normalizing their units.

For useful grocery price comparison by receipt, a system must reason about price per ounce, pound, count, liter, or another relevant unit. It also needs to distinguish multipacks, “buy one, get one” offers, and quantity-based discounts.

5. Geospatial and temporal comparison
Price data loses value when location and freshness are ignored. A price observed hundreds of miles away may not help someone deciding where to shop today. A six-month-old observation should not carry the same confidence as one submitted yesterday.

CartLens organizes price observations around merchant location and time. The comparison layer can then prioritize nearby, recent, and sufficiently similar observations instead of presenting every price as equally relevant.

6. A verdict a human can use

The final output should not be a wall of extracted text. It should answer practical questions:

Was this price fair compared with recent nearby observations?
Which items contributed most to the difference?
Is another store cheaper for one item or for the entire basket?
How recent and reliable is the comparison?
Would the potential savings justify an additional trip?

This is where an OCR utility becomes an AI shopping assistant that analyzes receipts.

From individual scans to a crowdsourced local price database

One receipt can help one person. A network of verified observations can help a community.

Each useful scan can add a timestamped price observation to what CartLens calls the Geospatial Lattice—a growing map of products, merchants, locations, and observed prices. As local coverage becomes denser, shoppers can receive more relevant comparisons.

The data loop looks like this:

A shopper scans a receipt or price tag.
The system extracts and normalizes the items.
Each usable observation updates the local price network.
Future shoppers receive stronger nearby comparisons.
Their scans contribute additional coverage.

This network effect is especially important for physical retail, where no single public catalog captures every store, product, promotion, and regional difference.

It also creates a difficult engineering problem: more data is not automatically better data. A useful crowdsourced pricing system needs mechanisms for duplicate detection, anomaly handling, freshness decay, location validation, and confidence thresholds. If a comparison is uncertain, the product should communicate that uncertainty instead of manufacturing precision.

Why basket comparison matters more than the cheapest single item

Most people do not shop for one isolated product. They buy a basket.

Store A may have cheaper cereal, while Store B has lower prices on milk, detergent, and produce. Driving to three stores to save a few cents can waste more time and fuel than it saves.

That is why CartLens is designed to support local store price comparison for an entire shopping list, not just one headline bargain. A useful recommendation has to consider:

the shopper's actual products;
comparable package sizes;
distance between stores;
the freshness of each price observation;
the total basket difference; and
whether splitting the trip is worthwhile.

The best result is not always the lowest theoretical price. It is the best practical decision for that shopper.

Privacy cannot be an afterthought

Receipts can expose more than prices. They may reveal where someone shops, when they shop, what they buy, and fragments of payment information. Any receipt-analysis platform should treat that data as sensitive.

CartLens is being built around data minimization and user control. The useful part of a crowdsourced price observation is the product, merchant node, price, and time—not a person's identity or movement history.

The platform's privacy approach emphasizes keeping user choices private, avoiding the sale of SKU-level behavior to advertisers, supporting data export, and allowing users to remove personal identifiers while preserving non-identifiable price observations.

There is a broader product principle here for developers: if your AI feature depends on personal data, privacy is part of the architecture—not a policy page added after launch.

What makes CartLens different from a basic receipt scanner app?

A conventional receipt organizer answers: “What did I spend?”

CartLens is intended to answer:

Did I overpay?
Where nearby was it cheaper?
Which store is more affordable for the items I actually buy?
How is my spending changing across stores and categories?
Which recurring purchases create the most avoidable overspending?

That makes it a retail price intelligence platform rather than only a receipt digitizer.

It is also designed for more than groceries. The same underlying workflow can apply to household essentials, pharmacy products, beauty items, electronics, pet supplies, and other categories where local prices vary.

What I have learned while building it

Several lessons extend beyond CartLens.

AI accuracy is a product experience, not one model score

A strong OCR model can still produce a weak product if normalization, matching, or confidence handling fails. End-to-end accuracy matters more than a single benchmark.

“Same product” is a domain decision

Exact matches, equivalent sizes, generic alternatives, and substitutes are different relationships. The interface must tell users which kind of comparison they are seeing.

Freshness belongs in the data model

A price without a timestamp is incomplete. Price observations should age, and the system should reduce confidence as they become stale.

Explainability builds trust

If an app says a shopper overpaid, it should show the comparison behind that conclusion: store, observed price, distance, date, unit basis, and confidence.

The shortest output may require the deepest system

“You paid a fair price” or “this item was $4 cheaper nearby” sounds simple. Producing that sentence responsibly may require computer vision, structured extraction, entity resolution, unit conversion, geospatial search, temporal weighting, and product design.

The larger opportunity: shopping intelligence for the physical economy

Retailers have sophisticated systems for pricing, inventory, demand forecasting, and customer segmentation. Individual shoppers rarely have equivalent tools.

I believe the next generation of consumer software will move beyond storing receipts and displaying charts. It will help people interpret purchases, compare realistic alternatives, detect unusual price changes, and make better decisions before the next checkout.

That is the direction behind CartLens: turn the receipt from a record of what already happened into intelligence for what to do next.

If you are interested in how to know if you overpaid for groceries, building a crowdsourced local price comparison app, or exploring how multimodal AI can make offline commerce more transparent, visit CartLens and take a look at the project.

I would also love to hear from developers working on OCR, product entity resolution, geospatial systems, privacy-preserving analytics, or retail data. What do you think is the hardest technical problem in making physical-store prices genuinely transparent?

Document Chat: Open Source AI-Powered Document Management

Christian — Fri, 24 Oct 2025 04:59:37 +0000

I recently launched Document Chat - a completely free, open-source platform that lets you upload documents and have intelligent AI conversations with them. Built with Next.js 15, powered by multiple AI providers, and ready to deploy in minutes.
🌐 Test it out: https://document-chat-system.vercel.app
💻 GitHub: https://github.com/watat83/document-chat-system
🎥 Watch Video Explainer: https://youtu.be/P42nlCmicVM

The Problem

We're drowning in documents. PDFs, Word files, research papers, contracts, manuals, reports - they pile up faster than we can read them. And when we need specific information? We spend hours searching, skimming, and hoping we haven't missed something important.
AI assistants like ChatGPT have shown us a better way - natural language conversations. But there's a catch: they don't know about YOUR documents. Sure, you can copy-paste snippets, but that's manual, tedious, and limited by context windows.
What if your documents could just… talk to you?
That's exactly what Document Chat System does. And unlike expensive proprietary solutions, it's completely free, open source, and yours to control.

What Is Document Chat System?

Document Chat System is a production-ready, open-source platform that combines document management with AI-powered conversational interfaces. Think of it as your personal AI librarian that has read every document you've uploaded and can answer questions about them instantly.

Key Features
✅ Multi-Format Support - PDFs, Word documents, images (with OCR), text files, and more
✅ Multiple AI Providers - OpenRouter (100+ models), OpenAI, ImageRouter for image generation
✅ Semantic Search - Vector embeddings with Pinecone or pgvector for accurate retrieval
✅ Multi-Tenant Architecture - Organizations, teams, role-based access control
✅ Background Processing - Inngest for scalable document processing
✅ Optional Monetization - Built-in Stripe integration for SaaS deployment
✅ Self-Hosted - Deploy anywhere, keep full control of your data
✅ MIT Licensed - Use it however you want, commercially or personally

Why I Built This

Over the past year, I've watched devs rebuild the same document chat features from scratch. It's a complex problem that requires:

Document parsing and text extraction
Vector embeddings and semantic search
AI provider integration and streaming
User authentication and multi-tenancy
File storage and processing pipelines
Rate limiting and error handling

Each dev reinventing the wheel, each facing the same challenges, each spending months on infrastructure instead of their unique value proposition.

I wanted to change that.
Document Chat System is the foundation I wish I had when I started building AI applications.

The Technical Stack

For developers curious about what's under the hood:

Frontend

Next.js 15 with React 19 and Server Components
TypeScript for type safety
Tailwind CSS + shadcn/ui for modern, accessible UI
Zustand for state management

Backend

Next.js API Routes for serverless functions
Prisma ORM with PostgreSQL
Clerk for authentication
Zod for runtime validation

AI & ML

OpenRouter - Access to 100+ AI models with a single API
OpenAI - GPT-4+, embeddings
Anthropic Claude - For longer context windows
ImageRouter - Multi-provider image generation

Infrastructure

Supabase - File storage and database
Pinecone or pgvector - Vector similarity search
Inngest - Background job processing
Upstash Redis - Caching and rate limiting
Docker - Production deployment

Optional

Stripe - Subscription billing and payments
Sentry - Error tracking and monitoring

Getting Started

Try It Now (2 minutes)
Visit https://document-chat-system.vercel.app
Sign up (it's free)
Upload a document
Start chatting!

Built for Everyone

For Developers

Modern Stack - Latest Next.js, React 19, TypeScript
Type Safety - End-to-end type safety with Zod validation
Clean Architecture - Modular, testable, documented
API First - RESTful APIs with clear documentation
Extensible - Easy to add new providers or features

For Businesses

Enterprise Ready - Multi-tenancy, RBAC, audit logs
Scalable - Background processing, caching, edge functions
Secure - AES-256 encryption, secure authentication
Compliant - Data isolation, configurable retention
Cost-Effective - No per-user fees, no vendor lock-in

For Entrepreneurs

Monetization Ready - Stripe billing built-in
White-Label - Fully customizable branding
Quick Launch - Deploy in minutes, not months
No Revenue Share - MIT licensed, keep 100% of profits
Support Options - Active community and documentation

Community & Contributions

Document Chat System is built by the community, for the community.

How to Contribute
⭐ Star the repo - It helps others discover the project
🐛 Report bugs - Open an issue on GitHub
💡 Suggest features - Share your ideas
🔧 Submit PRs - Code contributions welcome
📖 Improve docs - Help others get started
💬 Join discussions - Share use cases and feedback

Getting Help
📚 Documentation: https://github.com/watat83/document-chat-system
💬 Discord Community: https://discord.com/invite/ubWcC2PS

Pricing & Licensing

The Platform: 100% Free

Document Chat System is MIT licensed. This means:
✅ Free for personal use
✅ Free for commercial use
✅ No attribution required (though appreciated)
✅ Modify and distribute freely
✅ No revenue sharing
✅ No usage limits