Dealzo: The Price Tracker That Fires the CSS Selector

A Next.js app that turns product pages into structured data, watches prices like a market feed, and proves that AI scraping can simplify the whole stack.

6 to 8 min read • View on GitHub • More from Drashti-Mehta-22

A wide editorial scene of a technician at a drafting table studying a long product page unrolled like a scroll. On one side, brittle selector hooks snap off the page. On the other, a clean product form emerges with price and history reduced to structured blocks. The image explains Dealzo’s core idea: read the web by meaning, not by fragile layout. — Dealzo’s bet is simple. Let AI interpret the page once, then reuse that structure every time the price is checked.

Key Takeaways

Dealzo’s real innovation is not alerts or charts, but a parsing contract that treats product pages as meaning-rich documents instead of selector puzzles.
The app turns one extracted product record into a repeatable monitoring loop that compares price, appends history, and sends email only when something changes.
That design shifts maintenance away from brittle retailer-specific scrapers and toward a smaller system that is easier to reason about and extend.
The project is still an MVP, but its stack shows a clear pattern for building practical SaaS products with AI as infrastructure rather than the product itself.

The Web, Read Like a Form

Dealzo’s sharpest decision is also the simplest to explain. It does not chase product pages with a maze of site-specific selectors. It asks Firecrawl to read the page, understand the content, and return a structured product record.

That matters because storefronts are unstable by design. A small layout change can break a selector-based scraper overnight. Dealzo’s approach replaces that maintenance trap with one extraction contract that can generalize across retailers.

The repository’s own framing points in this direction: the project leans on AI-powered scraping, then stores the result in Supabase for tracking and alerts. The novelty is not that it tracks prices. It is that it makes the page legible first.

How Dealzo Turns a URL Into a Price Watch

The flow is clean. A user submits a product URL. Firecrawl extracts fields such as product name and current price. Supabase stores the product. A cron-protected route checks the record again later, compares the new price to the old one, and writes the result back into the database.

If the price changes, Dealzo updates the current product row, appends a new entry to price_history, and sends an email through Resend. If nothing changes, it keeps quiet. That restraint is part of the product design.

This is the core loop. Dealzo extracts once, then keeps comparing a stable record against the live page on a schedule.

Why LLM Parsing Beats Selector Maintenance

Traditional scrapers make a bet on structure. They assume the HTML will keep looking the same. Dealzo makes a different bet. It assumes the page will keep meaning the same thing, even when the markup shifts.

That changes the maintenance profile. Instead of patching rules for every retailer, the developer maintains one schema and one extraction contract. The trade-off is clear: AI parsing is less deterministic than a handcrafted selector, but it is far more adaptable across messy storefronts.

Approach	How pages are read	Maintenance cost	Coverage across retailers	Failure mode
Dealzo's AI extraction	By meaning, through a structured schema	Lower once the contract is stable	Broad, because the same parser can adapt to different layouts	Bad extraction when the model misses a field
Selector-based scraper	By exact DOM paths and CSS hooks	High, because every layout change can break it	Narrow, because rules are tied to specific sites	Broken selectors after a redesign
Narrow price tracker like CamelCamelCamel	By a fixed monitoring model around a limited set of sources	Moderate, but bounded by its source scope	Limited to the markets it supports best	Coverage gaps outside the supported catalog

A close-up control panel with a product URL entering one chamber, then moving through extraction, comparison, history logging, and alert dispatch. A price tag travels through the chambers like a baton in a relay. The image explains how Dealzo only triggers action when the price actually changes. — The monitoring loop behaves like a relay. Each stage hands off a stable record, and the alert branch only activates on a real drop.

The Heartbeat: Cron, Compare, Mutate, Notify

The price checker route is the system’s pulse. It fetches all tracked products from Supabase, re-scrapes each one, and checks whether the current price has moved. The repository analysis points to a guarded cron endpoint, which uses a secret in the authorization header to keep the loop controlled.

When the price changes, Dealzo performs a dual write. It updates the product row and inserts a new record into price history. That gives the app both a current state and a time series, which is exactly what a tracker needs.

This is also where the app feels disciplined. It does not flood the user with noise. It only emits an email when a meaningful delta appears.

Why the UI Feels Like a Market Terminal

The UI uses price history to turn shopping into something closer to portfolio tracking. A chart of consumer goods makes volatility visible. That framing matters because it changes the emotional register of the product.

Instead of a passive list of saved items, the user sees movement, risk, and opportunity. The app stops feeling like a bookmark folder and starts feeling like a market terminal for ordinary purchases.

That visual language is a strong fit for the product. The data is simple. The presentation makes it feel consequential.

What Dealzo Has, and What It Still Lacks

Dealzo looks like a thoughtful MVP, not a mature platform. The architecture is coherent, the stack is modern, and the extraction strategy is genuinely interesting. But there is little evidence of scale, community traction, or hard-won scraping resilience across hostile sites.

The repository also acknowledges the obvious problem. Some retailers use anti-bot defenses that can make scraping brittle regardless of the extraction method. AI helps with understanding, but it does not erase access control, rate limits, or blocked pages.

Strength	What Dealzo shows	What is still missing
Architecture	A clear loop built on Next.js, Supabase, Firecrawl, and Resend	Proof that it can hold up under larger traffic and more retailers
Extraction	A site-agnostic schema-based parsing model	Benchmark data on extraction accuracy across hard targets
Product maturity	A coherent end-to-end user flow	Community adoption, scale signals, and long-term reliability evidence

The Bigger Idea

Dealzo is a small example of a bigger shift in software design. AI is not only the feature at the top of the stack. It can also be the infrastructure layer that removes the ugliest part of the system.

Here, that ugly part is web scraping. By making the page legible once and storing the result as structured data, Dealzo turns a fragile workflow into a repeatable service. That is the real lesson: sometimes the smartest use of AI is to delete complexity, not add spectacle.