What a Product Recommendation Engine actually does
Surfaces personalized product recommendations on any Shopify storefront by combining collaborative filtering on purchase history with vector-similarity search over a product catalog — no login required.
The engine runs two parallel tracks. The first is a classical collaborative-filtering pass over order history stored in Supabase: products that appear together in completed orders are scored and ranked per visitor session using cosine similarity on pgvector. The second track embeds every product's title, description, and tags with text-embedding-3-small ($0.02/M tokens) so that browsing behavior — even anonymous — drives real-time content-based recommendations. An optional Claude Haiku 4.5 layer generates a one-sentence rationale tooltip ('we picked these because you've been browsing minimalist office gear') as a premium upsell feature, adding ~$0.002 per render when enabled.
The timing is right. The dominant recommendation platforms — Algolia AI, Coveo, Bloomreach, Klevu, Nosto — all price for the enterprise and offer zero rebrandable agency tiers. An ecommerce agency serving 10–50 Shopify merchants has historically had to buy separate seats per merchant or share a single account, destroying economics. With pgvector now included in Supabase's free tier and embedding costs at $0.02/M tokens, the infrastructure cost to run a 50-merchant white-label recommendation engine is under $50/mo total — resellable at $79–$149/mo per merchant with 90%+ gross margin.
AI capabilities involved
Product-catalog embedding and vector-similarity search
Collaborative filtering on purchase and session history
LLM-generated recommendation rationale tooltips
Frequently-bought-together mining from order history
A/B testing framework for recommendation placement strategies
Who uses this
- Ecommerce-agency CRO leads serving 10–50 Shopify merchants who want a rebrandable, self-branded recommendations widget
- Shopify Plus partners bundling AI personalization as a value-add in their retainer offering
- DTC growth consultants building a productized SaaS on top of a Lovable scaffold to serve multiple brands
- Independent Shopify app developers who want to compete with Nosto and Klevu on price without enterprise licensing
- Multi-brand ecommerce operators (3–10 portfolio DTC brands) who need a single internal recs layer across all storefronts
SaaS alternatives on the market
Real products you can sign up for today — with current 2026 pricing, honest pros and cons.
Algolia
Single DTC brands with $5M+ GMV that want enterprise-grade search + recs without an in-house ML team.
Free (10K search units/mo)
$250+/mo (Grow)
$2,000+/mo (Premium AI recs)
Pros
- +Best-in-class search relevance tuning with a visual dashboard — no ML expertise required.
- +Recommend API includes 'frequently bought together' and 'related products' out of the box.
- +100ms SLA for recommendation responses globally via Algolia's CDN.
- +Mature Shopify, WooCommerce, and Magento integrations with official apps.
Cons
- −No white-label tier — Algolia branding stays on the search/recs widget.
- −Per-search-unit billing means costs scale linearly with catalog size × monthly queries — hard to predict at agency scale.
- −AI personalization and A/B testing locked to $2K+/mo Premium tier.
- −All catalog embeddings and signals are stored in Algolia's infra — migrating out requires full re-indexing.
Nosto
Mid-market DTC brands ($2M–$20M GMV) that want a proven personalization layer with zero ML setup.
No free tier
$249/mo (Essentials)
Custom quote
Pros
- +Purpose-built for ecommerce personalization — homepage, PLP, PDP, and email placements all supported.
- +Behavioral segmentation on real-time session data without requiring customer login.
- +Native Shopify Plus and BigCommerce apps with visual editor for placement customization.
- +Pre-built 'recently viewed' and 'best sellers' widgets deploy in under an hour.
Cons
- −No white-label tier — Nosto brand appears in widget embed code and admin login.
- −Revenue-share pricing on higher-tier plans means costs scale with merchant GMV, not usage.
- −Personalization quality degrades significantly on catalogs under 500 SKUs (limited signal).
- −Migrating away requires rebuilding all placements from scratch in the new tool.
Klevu
Established DTC brands with $10M+ GMV and developer resources, where search-conversion improvement justifies the $699/mo floor.
No free tier
$699+/mo
Custom quote
Pros
- +AI-native search and discovery with semantic understanding of product attributes — 'floral summer dress' matches products without exact keyword.
- +Real-time merchandising rules (boost, bury, pin) that work on top of AI rankings.
- +Strong headless/API-first architecture suits custom Shopify storefronts.
- +Category page optimization included — not just search.
Cons
- −Floor at $699/mo per merchant makes it uneconomical for small DTC brands or agency pilots.
- −No white-label tier — Klevu brand in widget and admin.
- −Implementation requires developer resources for headless setups — not plug-and-play.
- −AI retraining on new catalog data can take 24–48 hours to propagate.
Bloomreach Discovery
Enterprise retailers ($100M+ GMV) running Salesforce Commerce Cloud or SAP commerce with complex catalog structures.
No free tier
Enterprise quote only
Pros
- +Best-in-class for large catalogs (1M+ SKUs) — purpose-built for enterprise retail.
- +LOUPE AI layer provides behavioral-signal personalization across search, recs, and email.
- +Strong B2B commerce support — complex product hierarchies and account-level pricing.
- +EU data residency options available.
Cons
- −No transparent pricing — enterprise quote only, typically $50K+/yr.
- −No white-label tier.
- −18–24 month contracts common — significant commitment before seeing ROI.
- −Overkill for agencies serving sub-$50M GMV merchants.
The AI stack
The recommendation engine has two mandatory layers (embeddings + vector search) and one optional premium layer (LLM rationale). Keep the core cheap — pgvector + text-embedding-3-small handles 95% of recommendation quality at near-zero cost; the LLM layer is a premium upsell, not a baseline requirement.
Product-catalog embeddings
Converts each product's title, description, and tags into a 1536-dimension vector stored in pgvector for similarity search
text-embedding-3-small
$0.02/M tokensDefault choice for any catalog up to 100K SKUs across all merchant tiers
Gemini 3.1 Flash-Lite
$0.25/$1.50 per M tokensFashion or home-decor merchants where visual similarity matters as much as textual similarity
Our pick: Default to text-embedding-3-small for all merchants. Add Gemini 3.1 Flash-Lite multimodal embeddings only for fashion/visual-heavy catalog clients where image similarity improves recommendation relevance — gate it behind a premium tier.
Vector store and similarity search
Stores and queries embedding vectors to find nearest-neighbor products for real-time recommendation serving
pgvector on Supabase
Free up to 500MB; Supabase Pro $25/mo for 8GBAll production deployments — the unified Postgres + vector approach eliminates a separate Pinecone/Qdrant dependency
Our pick: Use pgvector on Supabase Pro ($25/mo) for all production deployments. Free tier is fine for demos up to 50 merchants × 200 SKUs. Beyond 500K total vectors, evaluate HNSW index tuning or partition by merchant namespace.
Collaborative filtering
Mines 'frequently bought together' and 'also viewed' patterns from order and session history to score product affinity pairs
SQL co-occurrence queries on Supabase
$0 (Postgres compute only)All merchants with 6+ months of order history — run as a nightly batch job
GPT-5.4 nano ($0.20/$1.25 per M)
$0.20/$1.25 per M tokensCold-start merchants with fewer than 500 orders who need plausible recommendations on day one
Our pick: Default to SQL co-occurrence for all merchants with order history. Use GPT-5.4 nano for cold-start bootstrapping only — flag synthetic affinity pairs in the database and replace with real co-occurrence data as orders accumulate.
LLM recommendation rationale (premium)
Generates a one-sentence 'why we picked this' tooltip for each recommendation as a premium differentiator
Claude Haiku 4.5
$1/$5 per M tokensPremium merchant tier ($149+/mo) where the rationale tooltip is a differentiating feature
GPT-5.4 nano
$0.20/$1.25 per M tokensMid-tier merchants ($79–$99/mo) who want rationale as a feature but where per-unit AI cost matters
Our pick: Gate rationale tooltips behind a premium tier. Use Claude Haiku 4.5 for $149+/mo merchants, GPT-5.4 nano for $79–$99/mo tier. Never enable rationale on free-trial merchants — it burns margin before the merchant has converted.
Reference architecture
The pipeline has two distinct phases: an async ingest phase that runs nightly to embed the catalog and compute co-occurrence, and a synchronous serve phase that responds to recommendation API calls in under 100ms. The hardest engineering challenge is the Shopify webhook listener that keeps the catalog embedding index fresh when products are added, modified, or removed — stale embeddings silently degrade recommendation quality.
Merchant onboards and connects their Shopify store via OAuth
Next.js Shopify App Bridge + Supabase AuthThe OAuth flow captures the merchant's Shopify store URL and access token, stored encrypted in a tenant-isolated merchants table with RLS. Each merchant gets a dedicated Supabase namespace (schema or row-level filter) so catalog and order data never mixes across tenants.
Initial catalog ingest — all products fetched and embedded
Supabase Edge Function + text-embedding-3-small APIA Trigger.dev background job pages through the Shopify Admin REST API (250 products/page), concatenates title + description + tags for each product, batches into 2K-token chunks, and sends to text-embedding-3-small. Vectors are upserted into the pgvector products_embeddings table with merchant_id and product_id as composite key.
Co-occurrence matrix computed from order history
Supabase scheduled SQL function (nightly cron)A SQL window function aggregates the past 180 days of completed orders, counts how often each product pair appears in the same order, and writes scores to a product_affinities table. Pairs with co-occurrence count under 3 are excluded to filter noise.
Storefront widget loads and sends browsing context
Shopify Theme App Extension (client-side JS snippet)The widget fires a POST to the recommendation edge function with the current product ID (on PDP) or recent session product IDs (on homepage/PLP). The payload is under 1KB — just merchant_id, product_ids, and an anonymous session token.
Edge function queries pgvector and co-occurrence for ranked candidates
Supabase Edge Function (Deno)The function runs two parallel queries: a pgvector ANN (approximate nearest-neighbor) search for content-based candidates and a co-occurrence lookup for collaborative candidates. Results are merged with a weighted score (0.6 content + 0.4 collaborative by default, tunable per merchant) and top-N returned in JSON.
Optional: LLM rationale generated for premium merchants
Claude Haiku 4.5 API call (conditional on merchant tier flag)If the merchant's tier_flag = 'premium', the edge function sends the top-3 recommended product titles + the context product title to Haiku 4.5 and requests a one-sentence rationale per recommendation. This adds ~200ms latency and ~$0.002 cost — only triggered when the rationale feature is enabled.
Recommendation JSON served to storefront widget; widget renders placement
Shopify Theme App Extension (client-side render)The widget receives the ranked product list with optional rationale tooltips, renders the 'You might also like' carousel using the merchant's brand colors and font settings stored in the tenant config table, and fires a pageview event to the analytics table for A/B reporting.
Shopify webhooks keep catalog and orders fresh in real time
Supabase Edge Function webhook listenerProduct create/update/delete webhooks re-embed affected products within 60 seconds. Order-paid webhooks append to the orders table for next-night co-occurrence recompute. Webhook delivery failures are retried via Shopify's built-in 5-attempt policy; a failed_webhooks table catches any that exhaust retries.
Estimated cost per request
~$0.00001 per recommendation render (pgvector cache hit, no LLM rationale); ~$0.002 per render with Claude Haiku 4.5 rationale enabled
Cost calculator
Drag the sliders to model your actual usage. The numbers update in real time so you can stress-test economics before writing a single line of code.
The calculator models a multi-merchant white-label deployment. Fixed costs are shared across all merchants; per-unit costs scale with merchant count and monthly recommendation volume per merchant. Default assumes 20 active merchants each generating 10K recommendation renders/month.
Estimated monthly cost
$90.10
≈ $1,081 per year
Calculator notes
- pgvector query cost is effectively $0 — the $0.00001 figure accounts for Supabase compute time at Pro tier rates; at 200K renders/mo the Supabase Pro plan ($25) covers compute with headroom.
- Claude Haiku 4.5 rationale cost assumes an average 300-token input + 50-token output per recommendation render on the premium tier.
- Catalog re-ingest cost ($0.50/merchant/mo) assumes a 5,000-SKU average catalog re-embedded monthly for new products; merchants with 50K+ SKUs will cost proportionally more.
- Calculator excludes Shopify App Store fees (15–20% if distributed through the Shopify App Store) and any CDN egress beyond Vercel's 100GB/mo free allowance.
Build it yourself with vibe-coding tools
By Sunday night you'll have a working multi-tenant recommendation widget that pulls from a real Shopify dev store, serves pgvector-powered suggestions, and has a tenant admin dashboard for managing merchants — ready to pitch to your first 3 paying clients.
Time to MVP
12–16 hours (1 weekend)
Total cost to MVP
$25 Lovable Pro + ~$10 OpenAI embedding credits + free Supabase tier
You'll need
Starter prompt
Build a white-label AI product recommendation engine SaaS on Next.js + Supabase + pgvector. The app has two parts: (1) a merchant-facing admin dashboard where agency clients manage their Shopify connection and widget settings, and (2) a public recommendation API that the widget calls. Database schema (Supabase): - merchants table: id, name, shopify_domain, access_token (encrypted), tier ('standard'|'premium'), brand_color, created_at. Enable RLS so each merchant only sees their own rows. - products_embeddings table: id, merchant_id, product_id (Shopify), title, embedding (vector(1536)), updated_at. RLS on merchant_id. - product_affinities table: merchant_id, product_a_id, product_b_id, co_occurrence_score. RLS on merchant_id. - recommendation_events table: merchant_id, session_id, product_ids_requested, product_ids_returned, rendered_at. Admin dashboard pages: - /login — Supabase magic-link auth - /dashboard — overview: active merchant count, recommendation renders this month, top recommended products chart - /merchants — list + add merchants, enter Shopify domain + access token, select tier - /merchants/[id] — widget embed snippet (copy-paste), brand color picker, enable/disable rationale feature - /merchants/[id]/analytics — renders per day chart, top products, CTR if available API route (Next.js App Router Route Handler): - POST /api/recommend — accepts { merchant_id, product_ids: string[], session_id: string }. Queries pgvector for top-10 content-based neighbors (cosine similarity) and top-10 affinity pairs. Merges with weighted score (0.6 content + 0.4 affinity). Returns top-6 product recommendations as JSON. If merchant tier = 'premium', call Claude Haiku 4.5 for one-sentence rationale per recommendation. Edge Function (Supabase Deno): - ingest-catalog: accepts { merchant_id, shopify_domain, access_token }. Pages through Shopify Admin REST API products endpoint, sends title+description+tags to OpenAI text-embedding-3-small, upserts vectors into products_embeddings. Widget snippet (plain JS, no framework): - Reads current page's product ID from Shopify's window.meta.product - POSTs to the /api/recommend endpoint - Renders a 'You might also like' section with product title, image, price - Applies brand_color from merchant config for CTA button Styling: Tailwind CSS, clean agency-dashboard aesthetic, mobile-first. shadcn/ui components for admin. No public sign-up — merchants are added manually by the agency admin. Environment variables needed: NEXT_PUBLIC_SUPABASE_URL, NEXT_PUBLIC_SUPABASE_ANON_KEY, SUPABASE_SERVICE_ROLE_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY.
Paste this into Lovable
Follow-up prompts (run in order)
- 1
Add a nightly SQL co-occurrence function in Supabase that aggregates the past 180 days of order data from an orders table (merchant_id, order_id, product_ids jsonb array) and upserts co_occurrence_score into the product_affinities table. Schedule it as a Supabase pg_cron job at 2am UTC.
- 2
Add a Shopify webhook listener as a Next.js Route Handler at POST /api/webhooks/shopify that handles products/create, products/update, products/delete events. On create/update: re-embed the product and upsert into products_embeddings. On delete: remove from products_embeddings. Verify the X-Shopify-Hmac-Sha256 header against SHOPIFY_WEBHOOK_SECRET env var.
- 3
Add a Stripe billing integration: merchants are charged $79/mo (standard) or $149/mo (premium). On /merchants page, add a 'Billing' section that shows current plan and a 'Upgrade to Premium' button that creates a Stripe Checkout session. On successful payment (stripe webhook checkout.session.completed), update the merchant's tier in Supabase.
- 4
Add an A/B test framework: the recommendation API randomly assigns sessions to variant A (content-only recs) or variant B (content + affinity blend). The /merchants/[id]/analytics page shows CTR by variant. After 1,000 impressions per variant, declare a winner and lock the winning strategy for that merchant.
- 5
Add a CSV catalog import: on /merchants/[id] add an 'Import Catalog' button that accepts a CSV with columns product_id, title, description, tags. Parse client-side, POST to an /api/catalog/import route that batches embedding calls (100 products per batch) and shows a progress indicator.
Expected output
A working multi-tenant recommendation SaaS: agency admin can add merchants, connect their Shopify stores, configure the widget appearance, and copy an embed snippet that serves real pgvector-powered recommendations from their live catalog.
Known gotchas
- !pgvector's IVFFlat index requires at least 100× the number of lists as you have vectors for good recall — on Supabase free tier with default settings, ANN search quality degrades above ~10K vectors; tune the index with 'create index on products_embeddings using ivfflat (embedding vector_cosine_ops) with (lists = 100)' once you exceed 10K products.
- !Shopify's Admin REST API rate limit is 2 requests/second for standard plans — catalog ingest for a 10K-SKU merchant takes 40+ minutes; use the GraphQL Bulk Operations API instead for initial ingests above 2K products.
- !Lovable will generate the Shopify OAuth flow without the offline access mode scope — make sure the access token request includes 'access_mode=offline' so the token doesn't expire with the Shopify session.
- !The recommendation API will be called by the storefront widget from Shopify's CDN domain — add the merchant's Shopify domain to the CORS allowed origins list in the Route Handler response headers, otherwise the widget silently fails in production.
- !text-embedding-3-small produces 1536-dimension vectors by default; Supabase's pgvector has a 2,000-dimension limit per column, so this is fine — but if you try to use text-embedding-3-large (3072 dimensions) you'll hit a hard error.
- !Lovable's initial scaffold won't include rate limiting on the /api/recommend endpoint — add Upstash Redis rate limiting (100 requests/minute per merchant_id) before going live to prevent API abuse from scrapers.
Compliance & risk reality check
A recommendation engine that personalizes based on browsing and purchase history is a behavioral profiling system under GDPR and CCPA — and the EU's Digital Services Act has explicit transparency requirements for recommendation algorithms on platforms above a modest size threshold.
GDPR/CCPA consent for session-vector personalization
Storing anonymous session vectors and purchase history to personalize recommendations constitutes behavioral profiling under GDPR Article 4(4) and CCPA Section 1798.140(t). Merchants using your widget on EU or California customer storefronts must disclose this profiling in their privacy policy and provide an opt-out mechanism. The EU requirement applies even to anonymous sessions if the session ID is persisted in a cookie.
Mitigation: Provide merchants with a consent-mode flag in the widget configuration: when consent_mode=strict, the widget uses only non-personalized (popularity-based) recommendations until the customer accepts cookies. Document this in your merchant onboarding flow and provide a sample privacy policy clause they can add.
EU Digital Services Act (DSA) Article 27 — recommender system transparency
DSA Article 27 requires online platforms to provide at least one recommendation system not based on behavioral profiling. While this directly applies to very large online platforms (VLOPs, >45M EU users), agencies deploying recommendation widgets for EU-facing merchants should implement a transparency disclosure by mid-2026 to stay ahead of enforcement expansion. The FTC has also issued informal AI transparency guidance aligned with DSA principles.
Mitigation: Add a 'Why am I seeing this?' info tooltip to the recommendation widget that explains in plain language whether the recommendation is based on browsing history, purchase patterns, or popularity. This satisfies the spirit of DSA Article 27 and the FTC's 2026 AI labeling guidance at minimal engineering cost.
C2PA provenance for any AI-generated product imagery in recommendations
If the recommendation widget displays AI-generated product images (generated via gpt-image-2 or similar), the C2PA (Coalition for Content Provenance and Authenticity) standard and the FTC's 2026 AI labeling guidance require disclosure that the image is AI-generated. This applies if the merchant has used an AI storefront builder to generate hero or product images.
Mitigation: If your recommendation widget pulls product images from Shopify's CDN, you're showing the merchant's own product images — no C2PA requirement. Only flag this if you add an AI-generated 'lifestyle context' image feature to the widget.
SOC 2 Type II for agency clients requiring it before granting Shopify Admin access
Mid-to-large merchant clients (especially Shopify Plus accounts) often require SOC 2 Type II attestation before granting a third-party app Admin API access to their store. Without it, enterprise sales cycles stall at the security review stage.
Mitigation: For early-stage builds, use Vanta ($5,000–$10,000/yr) to begin a SOC 2 audit trail from day one. For pre-SOC 2 sales, provide a security questionnaire response documenting data isolation (RLS), encryption at rest (Supabase AES-256), and token storage practices.
Build vs buy: the real math
5–7 weeks
Custom build time
$13,000–$25,000
One-time investment
3–5 months
Breakeven vs buying
The buy-SaaS path doesn't exist at the white-label level — Algolia, Nosto, and Klevu all require per-merchant subscriptions with no reseller tier, so the real comparison is custom build ($13K–$25K) versus managing separate vendor accounts per merchant. At $249/mo per merchant (Nosto Essentials), serving 10 merchants costs $2,988/mo — $35,856/yr — versus a custom build at $13K–$25K one-time plus $200–$400/mo infra. The custom build breaks even in 5–8 months and then runs at 85–90% gross margin indefinitely. At 20 merchants, the annual SaaS spend balloons to $70K+/yr, making the custom build pay for itself in under 4 months. As model prices continue to fall per the ai-providers-market T8 decay curves, the per-render AI cost on a custom build drops automatically — that savings never flows back to you when you're locked into a vendor's per-request billing.
Skip the DIY — RapidDev builds the production version
A Lovable MVP gets you a demo. Production needs auth that doesn't leak data, AI calls that don't bankrupt you, observability when models drift, and code you can audit. That's what we ship.
Discovery call (free)
30 minWe map your exact Product Recommendation Engine use case: who uses it, target volume, AI model choice, integrations, compliance scope. You get a detailed scope document and fixed-price quote within 48 hours.
AI-accelerated build
5–7 weeksOur engineers use Claude Code, Lovable, and custom tooling to ship 3–5x faster than agencies. You see weekly progress in a staging environment — not a black box.
Launch + handoff
1 weekWe deploy to your infrastructure, transfer the GitHub repo, set up CI/CD and monitoring, and train your team. You own 100% of the source code, prompts, and model configurations.
What you get
Timeline
5–7 weeks
Investment
$13,000–$25,000
vs SaaS
ROI in 3–5 months
30-min call. Fixed-price quote within 48 hours. No commitment.
Frequently asked questions
How much does it cost to build a white-label AI product recommendation engine?
A RapidDev custom build runs $13,000–$25,000 for the full multi-tenant platform including Shopify App Bridge integration, pgvector recommendation engine, tenant admin dashboard, and Stripe billing. The Lovable DIY path costs $25 (Lovable Pro) plus ~$10 in OpenAI embedding credits for a working weekend MVP. Ongoing infrastructure on Supabase Pro + Vercel Pro runs $45–$100/mo regardless of merchant count.
How long does it take to ship a recommendation engine?
The Lovable DIY path produces a working multi-tenant MVP in a weekend (12–16 hours). A RapidDev custom build takes 5–7 weeks including Shopify App Bridge setup, pgvector index optimization, webhook listeners, and billing integration. The longest single task is initial catalog ingest for merchants with 10K+ SKUs — plan 1–2 extra days for large catalogs.
Can RapidDev build this for my agency?
Yes — RapidDev has shipped 600+ applications including multiple ecommerce personalization platforms. The standard engagement is $13,000–$25,000 for a production-ready white-label recommendation SaaS. Start with a free 30-minute consultation at rapidevelopers.com to scope your specific Shopify integration requirements and merchant count.
Does this compete with Algolia, or is it a different category?
It's the same category — product recommendations on ecommerce storefronts — but a fundamentally different economic model. Algolia sells per-merchant subscriptions (minimum ~$250/mo) with no rebrandable tier; your custom build serves N merchants from a single Supabase instance at a flat infra cost. At 10+ merchants, the economics flip decisively in favor of the custom build.
How do I handle the cold-start problem for new merchants with no order history?
Two approaches: (1) Use content-based recommendations only (pgvector similarity on product catalog) for the first 60–90 days — this works well for merchants with descriptive product titles and tags; (2) Optionally use GPT-5.4 nano to generate synthetic affinity pairs based on product attribute compatibility ('yoga mat' pairs well with 'yoga blocks' and 'meditation cushion'). Flag synthetic pairs in the database and replace with real co-occurrence data as orders accumulate — typically 500 orders gives enough signal for reliable collaborative filtering.
What's the recommendation latency in production?
pgvector ANN queries typically return in 20–50ms from a Supabase instance co-located with your Vercel edge functions. Adding the co-occurrence lookup is a parallel query that doesn't add to total latency. The optional Claude Haiku 4.5 rationale call adds 150–250ms — keep it conditional and document the latency impact to premium merchants. Total response time from widget fire to rendered carousel is typically under 200ms for standard tier, under 450ms for premium with rationale.
Can this work with WooCommerce or BigCommerce merchants, or only Shopify?
The pgvector recommendation engine is platform-agnostic — any storefront that can fire a JavaScript API call and display the response can use it. The platform-specific work is the catalog ingest connector (WooCommerce REST API instead of Shopify Admin API) and the placement widget (a Shopify Theme App Extension versus a generic JS snippet). Budget an extra 1–2 weeks of development to add WooCommerce or BigCommerce support beyond the Shopify scaffold.
What happens to my recommendation quality as I onboard more merchants?
Quality is per-merchant — each tenant has isolated catalog embeddings, order history, and co-occurrence data in their own RLS-protected rows. Onboarding a new merchant doesn't affect existing merchant recommendation quality. The only shared resource is Supabase compute, which scales on the Pro tier. At 100+ merchants with large catalogs, consider partitioning the pgvector index by merchant_id namespace to keep ANN query latency below 100ms.
Want the production version?
- Delivered in 5–7 weeks
- You own 100% of the code
- AI cost monitoring built in
30-min call. No commitment.