Find Profitable Products
Before Anyone Else

Organizational Structure

Authorized Brands

ADAW LLC maintains authorized distribution agreements with 32+ brands across multiple product categories including health & household, beauty & personal care, grocery, and home & kitchen.

Brand Relationship Overview

How Brand Data Integrates with DistroTrack

When the scanner discovers eligible products, it automatically detects and tracks the brand associated with each listing. This data feeds into the Brands tab, which provides:

• Brand-level analytics: Total products, average margins, and revenue estimates per brand
• Ungated highlighting: Brands we are authorized to sell are visually highlighted for quick identification
• Product drill-down: Click any brand to see all eligible products from that brand with full competitive analysis
• Export capabilities: Export brand-level data for sourcing and purchasing decisions

Compliance Overview

ADAW LLC maintains comprehensive compliance across all operational jurisdictions, ensuring legal and regulatory adherence for all distribution and sales activities.

Compliance Practices

What Is ADAW Scanner?

ADAW Scanner is a fully automated Amazon FBA product research tool built for wholesale and online arbitrage sellers. It scans Amazon's entire product catalog across thousands of categories, identifies products that are profitable, ungated, and low-competition, and presents them in a data-rich dashboard with actionable insights.

Unlike manual product research (which involves clicking through Amazon listings one by one), ADAW Scanner automates the entire pipeline:

The end result is a curated list of eligible products with detailed competitive analysis, fee breakdowns, sales estimates, and investment recommendations.

Alerts & Notifications: The scanner supports Discord Webhook alerts for high-quality Green Light products (score 7.0+ with 100+ monthly sales) and Browser Notifications for scan completion and Green Light batch discoveries.

How Scanning Works

The scan operates in three sequential phases, each building on the previous one:

Phase 1: Top Sellers Discovery

The scanner uses Keepa's Best Sellers API to fetch top-selling ASINs across all Amazon root categories. This costs approximately 36 Keepa tokens and returns 500K+ products ranked by sales demand.

Phase 2: Eligibility Pipeline

Discovered ASINs enter a multi-step eligibility pipeline. Key parameters:

• Batch processing: ASINs are checked in parallel batches
• Rate limits: Respects SP-API rate limits (1 request every 2 seconds for fees)
• Tiered enrichment: Green-scored products are enriched with Keepa data first

Phase 3: Eligibility Checking

Each discovered ASIN is evaluated through a multi-step pipeline. The scanner uses parallel API calls (threading) to maximize throughput:

Early Rejection

To save API calls, products are rejected early when they fail basic thresholds. However, offer details are still fetched even for rejected products (to detect Amazon on listing for scoring):

Early-rejected products still get basic data stored: estimated_monthly_sales, amazon_on_listing, fba_seller_count, buy_box_price, buy_box_seller. The scanner processes approximately 30-55 ASINs per minute depending on the eligibility rate.

Sales Estimation

Monthly sales estimates use verified Keepa data only. The Amazon "bought in past month" badge is never used as a primary signal — it counts unique customers (not units), shows only rounded ranges (50+, 100+, 200+), and is frequently stale.

Confidence multipliers affect the Sales Velocity score component: High = 1.0×, Medium = 0.7×, Low = 0.2×, None = 0.0×.

BSR Formula

The estimate_monthly_sales(bsr, category) function uses a power-curve formula calibrated against SellerAmp SAS ground truth (11 products cross-referenced, 73% error reduction vs prior calibration):

Category-specific (factor, exponent) pairs are defined for 27 categories (e.g., Home & Kitchen: 114069 × BSR^-0.77, Electronics: 237841 × BSR^-0.75). The formula requires the root category BSR from Keepa — subcategory BSRs from SP-API produce wildly inaccurate results.

Scoring & Green Light System

Every eligible product is scored using the Green Light Score, a composite rating based on real-world arbitrage viability criteria derived from extensive SellerAmp SAS analysis.

Hard Rejects (Instant Red)

This condition immediately disqualifies a product with a score of 0 (Red), regardless of all other criteria:

Weighted Components (0-10 scale)

The total theoretical maximum is ~10.5 points, clamped to 10.0. Products without Keepa data are rescaled from 0-9.0 to 0-10.0 so they aren't unfairly capped below the Green threshold.

Penalties

Score Labels

Top Opportunities Quality Gates

Products must pass ALL of these filters to appear in Top Opportunities:

Opportunity Score Formula

Products that pass all quality gates are ranked by a composite opportunity score:

Keepa Multipliers

If Keepa data is available, the base score is multiplied by trend factors:

Letter Grades

Opportunity scores are converted to percentile-based letter grades among all candidates:

The top 10 products by opportunity score are displayed on the Overview tab.

Category Intelligence

After running a Top Sellers scan, the Insights tab shows category-level analytics including hit rates, average margins, competition levels, and price sweet spots. Use this data to understand which product categories offer the best opportunities.

Prerequisites

Step 1: Amazon SP-API Setup

The scanner uses Amazon's Selling Partner API for all product data. You need 6 credentials:

1. Register as SP-API Developer: Go to sellercentral.amazon.com → Apps & Services → Develop Apps → Register as developer. Choose "Self-authorization" (you're accessing your own seller account).
2. Create an IAM User: In the AWS Console, create an IAM user with sts:AssumeRole permission. Save the Access Key ID and Secret Access Key.
3. Create an IAM Role: Create an IAM role with a policy that allows execute-api:Invoke on arn:aws:execute-api:*:*:*. Set the trust policy to allow your IAM user to assume the role. Copy the Role ARN.
4. Create an LWA App: In Seller Central → Develop Apps, create a new app. After approval, note the LWA Client ID and LWA Client Secret.
5. Self-Authorize: Authorize the app on your own seller account. This generates a Refresh Token.
6. Get your Seller ID: In Seller Central → Account Info → Your Merchant Token (also called Seller ID).

You now have these 6 values:

Also set your marketplace and seller:

Step 2: Supabase Auth Setup

Supabase provides user authentication (login/logout, JWT tokens, password reset). It's free for small projects.

1. Go to supabase.com and create a free account.
2. Create a new project. Choose a name and set a database password (you won't use the DB directly).
3. Go to Settings → API and copy:
   • Project URL → this is your SUPABASE_URL
   • anon / public key → this is your SUPABASE_ANON_KEY
   • JWT Secret (under "JWT Settings") → this is your SUPABASE_JWT_SECRET
4. Go to Authentication → Providers and ensure Email is enabled.
5. Go to Authentication → Users and create a user with email + password. This will be your login credential.

Step 3: Keepa API Setup (Optional)

Keepa provides 90-day historical data (price trends, sales rank, competition changes). Without it, the scanner still works but scores max at 8/10 instead of 10/10 (the Keepa Trends component adds up to 2.0 points).

1. Go to keepa.com and create an account.
2. Subscribe to the API Starter Plan (€49/mo). This gives you 20 tokens/minute.
3. Go to your API settings and copy your API key.

Token budget: Each product query costs 1 token. At 20 tokens/min you can enrich ~1,200 products/hour.

Step 4: Clone & Install

The requirements.txt includes: flask, python-amazon-sp-api, gunicorn, PyJWT, keepa, numpy, python-dotenv, psutil.

Step 5: Configure Environment Variables

Create a .env file in the project root with all your credentials:

Step 6: Run Locally

Open http://localhost:5000 in your browser. If SUPABASE_JWT_SECRET is empty, you'll be logged in automatically.

The SQLite database (checked_asins.db) is auto-created on first run with all required tables and schema migrations.

Step 7: Deploy to Railway

1. Push your code to a GitHub repository.
2. Go to railway.app and create a new project. Choose "Deploy from GitHub repo" and select your repository.
3. Add a persistent volume: In your Railway service, go to Settings → Volumes → Add Volume. Mount it at a path like /data. Set DB_PATH=/data/scanner.db so the database survives redeploys.
4. Set environment variables: In Settings → Variables, add all the env vars from Step 5 (with real values this time, including SUPABASE_JWT_SECRET).
5. Add a custom domain (optional): In Settings → Networking → Custom Domain, point your domain to Railway.
6. Railway auto-deploys on every push to main. The Procfile tells Railway how to start:
   web: gunicorn dashboard:app --bind 0.0.0.0:$PORT --workers 2 --timeout 120

Step 8: Verify Everything Works

Complete Environment Variables Reference

Project File Structure

How It Works

The Top Sellers scan uses Keepa's Best Sellers API to fetch the top-selling ASINs across all Amazon root categories. It directly pulls pre-ranked bestseller lists — getting you to the highest-demand products fast.

Process Flow

1. Fetch Root Categories — Gets Amazon's ~37 root categories from Keepa (1 token)
2. Pull Bestsellers — For each root category, fetches up to 100K top-selling ASINs (~1 token each, ~36 tokens total)
3. Deduplicate — Merges results and removes ASINs already in your database
4. Eligibility Check — Runs the standard SP-API eligibility pipeline on all new ASINs
5. Enrichment — Keepa enrichment worker auto-enriches eligible products with sales data

Token Cost

When to Use

• First-time setup — Great starting point. Gets you 500K+ high-demand ASINs instantly.
• Regular rescans — Only costs 37 tokens per scan. Run periodically to discover new top sellers.
• Quick discovery — Directly pulls pre-ranked bestseller lists from Keepa.

Safeguards

• Budget check — Won't start if you don't have enough Keepa tokens (need ~37).
• Stacking prevention — Won't start if >100K unchecked ASINs are already queued.
• Deduplication — Uses INSERT OR IGNORE to avoid duplicate ASINs in the queue.
• Budget exhaustion — If tokens run out mid-scan, it stops gracefully and proceeds with ASINs collected so far.

Technology Stack

ADAW Scanner is built with a modern, lightweight stack designed for reliability and speed:

Architecture Overview

The system consists of several core files:

Data Flow

When a scan starts, dashboard.py spawns finder.py as a subprocess. The scanner writes results to the database as it runs. The dashboard polls the DB every 1 second to show live progress. All scan ↔ dashboard communication happens through the shared database.

Key Processes

Shared Catalog & Enrichment Service

A background enrichment service (enrichment.py) runs as a separate Railway worker, maintaining a global shared_catalog table with Keepa sales data for 550K+ ASINs. All tenants share this data — ADAW absorbs the Keepa API cost. The enrichment service runs on a 4-hour cycle with 60 tokens/min Keepa plan.

• Web service — dashboard.py via Gunicorn (serves UI + API)
• Enrichment service — enrichment.py (background Keepa enrichment loop)
• PostgreSQL — shared database between both services

Frontend Build Pipeline

Production serves 2 minified bundles built by node build.js: app.min.js (172KB) and app.min.css (141KB). Development mode serves 19 separate files (14 JS modules + 5 CSS files). The dashboard auto-detects which to serve based on static/dist/ existence.

System Diagram

Three Railway services share one PostgreSQL database. The web service runs the dashboard and scanner. The enrichment service runs Keepa data collection independently.

Scan Pipeline

When you click Start Scan, the system progresses through these phases:

Data Enrichment Cycle

The enrichment service runs independently on a 4-hour cycle, fetching fresh Keepa data for products in the shared catalog:

Sales Estimation Hierarchy

When displaying estimated monthly sales, the system uses verified Keepa data in priority order:

External Integrations

API Rate Limits & Performance

Amazon's SP-API enforces strict rate limits per endpoint. The scanner is designed to operate at maximum efficiency within these constraints:

Throughput Estimates

• Category discovery: ~4 pages/second (limited by Catalog Search rate)
• Eligibility checking: ~30-55 ASINs/minute (depends on how many pass the $12 threshold)
• Top Sellers scan: ~2 minutes for discovery (500K+ ASINs), then eligibility pipeline runs
• Keepa enrichment: ~1,200 products/hour (1 token/product, 20 tokens/min on Starter plan)

Dashboard API Endpoints

The Flask backend exposes 50+ authenticated API endpoints. All require a valid JWT token via the Authorization: Bearer header (except the public waitlist POST and /health endpoint).

Stats & Analysis

Products & Details

Insights & Analytics

Scan Control

Scan History & Sessions

Keepa & Enrichment

Export & Brands

Waitlist (Public)

Database & Data Model

Production uses PostgreSQL on Railway. Local development uses SQLite with WAL mode. The db.py abstraction layer auto-translates SQL between both dialects (INSERT OR REPLACE → ON CONFLICT, LIKE → ILIKE, boolean casting, etc). All tables include a tenant_id column for multi-tenant isolation. The keepa_cache table is the exception — it is global (shared across all tenants) to avoid re-fetching the same ASIN data per user. Schema migrations run automatically on startup.

Table: checked_asins (Products)

The main products table. Every ASIN that has been evaluated is stored here, regardless of eligibility.

Table: scan_categories (Browse Tree)

Table: scan_asins (Discovery Queue)

Table: scan_sessions (History)

Table: scan_meta (Key-Value Store)

Table: waitlist (SaaS Signups)

Table: shared_catalog (Global Sales Data)

Table: watchlist (User Favorites)

Indexes

• idx_session on checked_asins(scan_session_id) — fast session-based product filtering
• idx_scan_categories_status on scan_categories(is_leaf, scan_status) — fast pending-category lookups
• idx_scan_asins_unchecked on scan_asins(eligibility_checked) — fast unchecked-ASIN batch fetching

Keepa Integration

Keepa provides 90-day historical data for every product, enriching the scanner's real-time data with trends and context:

• Price history: Track price stability via coefficient of variation (CV). CV < 0.15 = stable pricing, CV > 0.25 = volatile
• Sales rank trends: Identify products with improving (growing demand) or declining (shrinking demand) sales rank over 90 days
• Competition changes: Monitor seller count fluctuations — increasing seller count triggers a -1 scoring penalty
• Monthly sold estimate: Keepa's proprietary "bought in past month" badge data, often more accurate than BSR-based calculations
• Sales rank drops: Count of 30-day rank drops (BSR dips that indicate sales events)

How It Works

Keepa data is fetched via the Shared Catalog enrichment service, which runs as a background worker refreshing sales data weekly. Each product lookup costs approximately 3 API tokens (1 base + 2 offers). ADAW absorbs the Keepa API cost — users don't need their own Keepa subscription. The Data Enrichment section on the Overview tab shows coverage and freshness.

Keepa data is now maintained by the Shared Catalog enrichment service (enrichment.py), which runs as a background Railway worker. The dashboard reads from the shared_catalog table first (Priority 0), falling back to per-tenant Keepa columns if unavailable.

Token Budget & Rate Limits

Monthly Sold: 3-Tier Priority

The scanner extracts monthly sales data from Keepa using a 3-tier priority to get the freshest value:

Each tier is validated: value must be non-null and > 0 before use. If all three are missing, the scanner falls back to BSR-based estimation.

Live Refresh (update=1)

When the product modal requests live Keepa data, the enrichment worker processes the request via the enrichment queue. The Keepa API default is update=1, which refreshes data if it's older than 1 hour — matching SellerAmp SAS freshness.

Monkey-Patch for Keepa Library Bug #221

The official keepa Python library has a known bug (#221) where update_status() overwrites self.status from a proper Status dataclass to a raw Python dict, causing 'dict' object has no attribute 'refillRate' errors.

The scanner patches this in keepa_client.py with a replacement _safe_update_status() that detects dict corruption and reconstructs a proper Status dataclass with all attributes.

Numpy Type Safety (_safe_scalar())

Keepa returns numpy types (arrays, scalars) that fail Python boolean comparisons (if val and val > 0 raises "ambiguous truth value" errors). The _safe_scalar() utility converts numpy types to plain Python scalars before comparison. It handles: numpy integers/floats (.item()), single-element arrays, multi-element arrays (returns None), and passes through regular Python values unchanged.

Price & Rank Data Handling

• Prices stored in cents: Keepa stores all prices as integers in cents — divided by 100 for dollar values
• Price priority: Amazon price first, falls back to New (marketplace) price if unavailable
• Buy Box price: Extracted from stats index 17 (BUY_BOX_SHIPPING) in the current array
• Invalid values: -1 = out of stock/unavailable, NaN = no data. Both filtered before analysis
• Keepa epoch: Times stored as integer minutes since 2011-01-01 00:00:00 UTC

Deployment & Infrastructure

Railway Platform

The application is hosted on Railway, a modern cloud platform:

• Auto-deploy: Every push to the main branch on GitHub triggers an automatic deployment
• Build time: ~1-2 minutes for Docker image build
• Container creation: ~3-5 minutes for new container startup
• Total deploy time: ~5-7 minutes end to end
• Zero-downtime: Railway performs rolling deploys (new container starts before old one stops)
• Persistent volume: SQLite database stored on mounted volume (web-volume) that persists across deploys

Procfile & Gunicorn

The Procfile tells Railway how to run the app:

• --workers 2 — Two Gunicorn worker processes (sufficient for single-user dashboard)
• --timeout 120 — 120-second worker timeout (important: long-running scan API calls can take time)
• $PORT — Railway automatically sets this environment variable

Environment Variables

All sensitive configuration is stored as Railway environment variables (never in code). See the From-Scratch Setup page for the complete reference table. Key groups:

Orphan Session Cleanup

When Railway redeploys, any running scan processes are killed. On startup, the application automatically calls _cleanup_orphaned_sessions() which:

1. Queries all sessions with status = 'running'
2. Updates each to status = 'stopped' with stopped_at = current timestamp
3. Logs the count and IDs of orphaned sessions found

This prevents stale "Running" indicators on the dashboard after a redeploy.

Database Persistence

The SQLite database (checked_asins.db) is stored on a Railway persistent volume. The DB_PATH environment variable points to the volume mount location. If DB_PATH is not set, the database is created in the script's working directory. The database is auto-created with all tables and indexes on first run via init_db().

Enrichment Service

The enrichment service runs as a separate Railway worker using the same GitHub repo but with ENRICHMENT_MODE=1 environment variable. The Procfile conditional routes to python enrichment.py instead of Gunicorn.

Required variables: DATABASE_URL, KEEPA_API_KEY, ENRICHMENT_DAILY_BUDGET, ENRICHMENT_INTERVAL_HOURS, ENRICHMENT_MODE=1

Discord Webhook Alerts

Set DISCORD_WEBHOOK_URL on the web service to receive Discord notifications for high-quality Green Light products (score 7.0+ with 100+ monthly sales). The webhook is non-blocking and fires from the /api/analysis endpoint during dashboard polling.

Authentication & Security

The dashboard uses Supabase Authentication (an open-source Firebase alternative) for user management.

Supabase Setup

To set up authentication from scratch:

1. Create a free project at supabase.com
2. Enable Email/Password auth in Authentication → Providers
3. Copy three values from Project Settings → API:
   • SUPABASE_URL — Project URL (e.g., https://xxxxx.supabase.co)
   • SUPABASE_ANON_KEY — Public anon key (safe to embed in frontend)
   • SUPABASE_JWT_SECRET — JWT signing secret (under Settings → API → JWT Secret)
4. Create your user account in Authentication → Users → Invite User

How Authentication Works

Email Allowlist

The ALLOWED_EMAILS environment variable restricts dashboard access to specific email addresses:

Comma-separated list. If empty or not set, all authenticated Supabase users can access the dashboard. If set, users whose email is not in the list receive a 403 "Access denied" response even with a valid JWT.

Local Development Mode

When SUPABASE_JWT_SECRET is empty or not set, the @require_auth decorator allows all requests through without authentication. This lets you develop and test locally without setting up Supabase:

authFetch() Flow

Every API call from the frontend JavaScript uses authFetch() instead of plain fetch():

Dashboard Tabs Explained

Overview Tab

Your command center. Shows real-time scan progress, key metrics, and quality distribution:

• Scan Progress: Phase indicator, categories scanned, ASINs discovered/checked, eligible count
• Discovery & Eligibility bars: Live progress bars showing Phase 2 (category scanning) and Phase 3 (ASIN checking) completion
• Product Intelligence: Estimated monthly profit, average fee margin, top category, average competition
• Keepa status: How many products have been enriched with historical data
• Quality Distribution: Visual breakdown of Green/Yellow/Red scores across all eligible products
• Top Categories & Price Distribution: Bar charts showing where your best opportunities cluster

Products Tab

The product research table. Every row is a fully eligible, ungated FBA product:

• Search: Filter by product name, ASIN, or category in real-time
• Green Light Only: Toggle to show only top-scored (Green) products
• Hide Amazon Buy Box: Exclude products where Amazon holds the Buy Box
• Category filter: Dropdown filter for focused research
• Price range: Set min/max price bounds
• Column sorting: Click any column header to sort ascending/descending
• Product Modal: Click any product row to see detailed analysis including Per-Seller Forecast, Competition Analysis, Keepa data, and Investment Thesis
• SAS Export: Export your product list as ASINs or full CSV for use with SAS (Seller Assistant) or other tools

New features include: Watchlist (star icon to save products), Product Comparison (select 2-3 products for side-by-side), Keyboard Shortcuts (press ? for help), and Mobile Card Layout (responsive cards on phones <768px).

Categories Tab

View all scanned Amazon categories with performance metrics:

• Discovered: How many ASINs were found in this category
• Checked: How many ASINs have been eligibility-checked
• Eligible: How many passed all checks (green badge = high count)
• Hit Rate: Percentage of checked ASINs that were eligible (higher = better category)
• Pages: How many pages were scanned in this category
• Scanned At: When this category was last scanned (relative time)

Insights Tab

Data analytics dashboard providing strategic intelligence about your scan results:

• Category Intelligence: Ranks all scanned categories by a composite score (0-100) based on hit rate, margin, sales volume, and competition
• Price Sweet Spots: Bar charts showing product distribution and green rate across price bands ($10-15, $15-25, etc.)
• Competition Landscape: Average seller count by category, Amazon/retailer presence rates
• Keepa Trend Analysis: Aggregated trend data showing improving vs declining products
• Smart Scan Plan: Preview of the AI-generated scan plan with tier breakdown before launching

History Tab

Complete record of every scan session:

• Session cards: Each card shows timestamp, type (Full/Targeted/Smart), status (Completed/Stopped), duration, and results
• Type badges: FULL (standard scan), TARGETED (specific categories), SMART (AI-optimized), PRE-HISTORY (data from before session tracking)
• Quality breakdown: Green/Yellow/Red count per session
• Click to drill down: Click any session card to see its products

Brands Tab

Brand-level intelligence across all your scan data. Uses a two-pass brand detection algorithm:

• Pass 1 — Known Brands: Matches product names against a curated dictionary of brand keywords. Single-word keywords (e.g., "Starburst") must start the product name. Multi-word keywords (e.g., "Arm & Hammer") can appear within the first 60 characters. Matched brands are labeled as Ungated.
• Pass 2 — Auto-detected: For unmatched products, extracts the first meaningful word of the product name (filtering out articles, colors, numbers). These brands are labeled as auto-detected.
• Minimum 3 products: Brands with fewer than 3 products are filtered out as noise
• Deduplication: Case-insensitive merging (e.g., "CLOROX" and "Clorox" become one brand)

Each brand card shows: product count, ungated status, parent company, categories, and all associated listings with prices, margins, sales, and scores. Brands are sorted by number of listings with 100+ monthly sales. CSV export is available for bulk analysis.

Top Opportunities (Overview Tab)

The Overview tab features a Top 10 Opportunities section — the highest-ranked products that pass all quality gates (no Amazon, 5+ sellers, 1+ FBA seller, non-Red, $3+ profit). Each card shows the opportunity score, letter grade (A+ through C), and key metrics. Products are ranked by the composite opportunity score which factors in sales volume, margin, competition, and Keepa trends.

Help Tab

Quick reference for the dashboard's features, filter options, modal fields, and scoring criteria.

FAQ & Troubleshooting

v3.0 — April 2026 (Current)

Architecture

• Shared Catalog: global shared_catalog table (550K+ ASINs) replaces per-tenant Keepa enrichment
• Enrichment Service: background worker (enrichment.py) on separate Railway instance
• Frontend: 14 JS modules + 5 CSS files, minified to 2 production bundles
• Hash Routing: deep-linkable URLs (#/overview, #/products, etc.)
• HTML Templates: product rows, history cards, opportunity items use <template> cloning
• Adaptive Polling: 2s during scan, 10s when idle (was fixed 5s)
• PWA: manifest.json + service worker for installable app experience

Features

• Watchlist/Favorites: star products, filter by watchlist, persisted per tenant
• Product Comparison: side-by-side view of 2-3 products
• Keyboard Shortcuts: /, j/k, Enter, s, ? for power users
• Interactive Charts: click quality/category/price bars to filter Products tab
• Browser Notifications: scan complete + Green Light batch alerts
• Discord Webhook: real-time alerts for Green products (score 7.0+, sales 100+)
• Mobile Card Layout: products table converts to cards on phones
• Loading Skeletons: shimmer placeholders during data loads

Accuracy

• Private Label Detection: -0.5 score penalty when avg sellers < 2.0
• Stale Badge Detection: CHECK 3 drops-vs-badge divergence (5x ratio)
• BSR Fallback: Keepa rank used when SP-API returns no BSR
• Keepa Price Validation: hide misleading prices that diverge >3x from sale price
• Top Opportunities: minimum 100 sales/mo gate added

Infrastructure

• Health Endpoint: /health for Railway monitoring
• Diagnostic Endpoint: /api/diagnostic/shared-catalog for catalog health
• Python Logging: structured logging module (replacing 444 print statements)
• Test Suite: 10 pytest tests (scoring, health, security)
• Security: removed hardcoded Discord webhook, env-var only
• Font Consistency: global font-family: inherit fix for all buttons/inputs

v2.0 — March 2026

Complete system overhaul: new scan modes, redesigned UI, cost optimizations, performance improvements, and 30+ bug fixes.

New Features

UI/UX Improvements

Performance Optimizations

Cost Architecture

The scanner uses two external APIs with usage-based costs. Our optimization strategy reduces total API calls by ~80% without sacrificing data quality.

SP-API Call Reduction

Keepa Token Optimization

The Shared Catalog architecture further reduces costs by 90%: one Keepa plan (~$100/mo) serves all tenants via the shared_catalog table, vs $500+/mo for per-tenant enrichment.

Per-Product API Cost Breakdown

Critical Fixes

UI/UX Fixes