PriceVerdict

Check any quoted price against live market evidence. PriceVerdict uses SerpApi, AI-assisted product matching, and deterministic pricing logic to tell you if a deal is fair.

Comment

Inspiration

Getting quoted a price sounds simple, but verifying whether that price is actually fair is surprisingly difficult.

Search results can mix different models, bundles, conditions, quantities, accessories, subscriptions, rentals, and even completely different products. A raw list of shopping results is not enough — the difficult part is deciding which offers are actually comparable.

I built PriceVerdict around one question:

“Before I pay, can I get a trustworthy verdict on this exact quoted price?”

The goal was to create something narrow, practical, and explainable: one product description, one quoted price, one live market audit.

What it does

PriceVerdict checks a quoted product price against live shopping-market evidence.

The user provides:

  • a product description
  • the quoted price

PriceVerdict then:

  1. Understands the exact product identity, including model, condition, product form, and critical attributes.
  2. Searches the live shopping market through SerpApi.
  3. Treats every search result as a candidate rather than immediately trusting it.
  4. Normalizes and validates listings.
  5. Rejects incompatible models, variants, conditions, bundles, offer types, and currencies.
  6. Uses deterministic matching first, with AI only for genuinely ambiguous product identity.
  7. Deduplicates accepted evidence and filters statistical outliers.
  8. Refuses to issue a verdict when there is not enough reliable evidence.
  9. Calculates the market median, interquartile range, verdict, and confidence using deterministic pricing logic.
  10. Shows both the evidence it accepted and the listings it deliberately rejected.

The result is one of:

Good Deal, Fair Price, Overpriced, or Not Enough Data.

How I built it

PriceVerdict uses a Java 21 / Spring Boot backend with a React, TypeScript, and Vite frontend.

The core pipeline is intentionally separated into stages:

Product input → structured product identity → SerpApi live search → candidate normalization → deterministic matching → AI ambiguity resolution → evidence cleanup → deterministic pricing → inspectable result

SerpApi is the live market-data source and provides structured Google Shopping results localized to the user's browser market and language.

OpenAI is used only where semantic understanding is useful:

  • structuring messy product descriptions
  • normalizing candidate identity
  • resolving uncertain matches

AI is not used to decide whether a price is cheap or expensive.

Once the evidence set is finalized, deterministic Java code calculates the median, market range, verdict, and confidence.

I also used ChatGPT (GPT-5.6 Sol) during development as an engineering assistant for brainstorming, code review, debugging, testing ideas, architecture discussion, and documentation. I made the system-design decisions, implementation choices, validation rules, and final product behavior, and verified them directly in the codebase.

Challenges I ran into

The biggest challenge was realizing that search results are not automatically evidence.

A product search can return:

  • neighboring models
  • body-only vs kit products
  • bundles with extra accessories
  • refurbished or used listings
  • rentals, subscriptions, or financing offers
  • different quantities
  • incompatible currencies
  • duplicate listings
  • statistical outliers

The hard part was therefore not retrieving prices — it was building a pipeline strict enough to decide which prices were actually comparable.

Another challenge was balancing deterministic rules with AI. Using AI for everything would have made the system easier to build, but much harder to trust. I instead used deterministic checks wherever possible and only sent uncertain identity cases to AI.

I also had to handle live-data variability. The same query can produce different shopping results at different times, so the matcher and evidence pipeline needed to remain conservative and reproducible even when the external result set changes.

Accomplishments that I'm proud of

The biggest accomplishment is that PriceVerdict is a finished, deployed, end-to-end product, not just a concept or static demo.

I’m especially proud of:

  • making SerpApi a core part of the product rather than a decorative integration
  • separating AI-assisted identity resolution from deterministic financial logic
  • building explainable accepted and rejected evidence
  • supporting market and currency localization
  • implementing evidence deduplication and outlier filtering
  • returning Not Enough Data instead of inventing confidence when evidence is weak
  • building a substantial automated test suite covering matching, pricing, validation, localization, evidence handling, rate limiting, and regression cases
  • demonstrating the system live across simple, ambiguous, and insufficient-evidence scenarios

I intentionally kept the product focused:

one product, one quote, one live evidence-backed verdict.

What I learned

The biggest lesson was that reliability often comes from refusing to simplify the wrong part of the problem.

Fetching shopping results is easy. Deciding whether two commercial offers are truly comparable is much harder.

I learned that AI works best here as a narrow reasoning tool rather than as the final authority. Deterministic rules are better for hard contradictions and financial calculations, while AI is useful for the small semantic gray zone between them.

I also learned how important inspectability is. A verdict is much more useful when the user can see not only what the system trusted, but also what it rejected and why.

What's next for PriceVerdict

The next step is expanding PriceVerdict carefully without losing the precision-first approach.

Potential improvements include:

  • broader product-category coverage
  • richer historical price context
  • more detailed merchant/source quality signals
  • improved identity normalization for difficult retail categories
  • additional market and currency coverage
  • stronger observability and analytics
  • larger regression datasets for matching edge cases

The core principle will remain the same:

SerpApi finds the market. PriceVerdict decides which evidence deserves to be trusted.

Before you pay — get a PriceVerdict.

Built With

Share this project:

Updates

Submission history