CatalogIQ

Turning messy industrial product data into structured intelligence you can actually trust.

Comment

Inspiration

Industrial commerce runs on product data that's scattered everywhere — websites, PDF spec sheets, scanned catalogs, half-written descriptions from suppliers. When Unilog's UniHack challenge asked for a way to turn that mess into structured, trustworthy product intelligence, one detail stood out: the brief specifically called for explainable outputs, not just accurate ones.

That's the part most AI tools skip. They'll happily fill in a missing spec with a confident-sounding guess and never tell you it was a guess. In an industrial setting, a wrong pressure rating or material spec isn't a minor bug — it's a safety and liability risk. We wanted to build something that didn't just generate data, but told you exactly how much to trust each piece of it.

What it does

CatalogIQ takes a short or incomplete product description — a spec-sheet snippet, a catalog line, a rough paragraph — and turns it into a clean, structured product record. Every field in the output is tagged with:

  • 🟢 Confirmed — taken directly from the input text
  • 🟡 AI-Inferred — estimated using standard category norms, with a confidence score
  • 🔴 Unknown — flagged for human review instead of silently guessed

On top of single-product extraction, CatalogIQ supports multiple product categories, a batch mode for processing several entries at once, initial support for PDF/DOCX/image input alongside raw text, and one-click JSON/CSV export so results can plug into an existing catalog or PIM system. Every analysis is stored and retrievable from a history panel.

How we built it

The stack: a React frontend, a Python/FastAPI backend, OpenAI for structured extraction (JSON-mode schema output), and AWS for hosting — Amplify for the frontend, Elastic Beanstalk for the backend API, and DynamoDB for persisting product records.

We designed a fixed schema per product category up front, then built a single extraction prompt that returns every field with a source and confidence value attached — that provenance tagging is the core of the whole product, so it was the first thing we got working end-to-end before touching UI polish.

Given the short timeline, we deliberately built in this order: backend + AI pipeline first (with mock data to avoid burning API budget while iterating), then a working frontend loop, then deployment — done early rather than left for the last hours — and only then visual polish and motion.

Challenges we ran into

  • Learning AWS deployment under a hard deadline. Elastic Beanstalk and Amplify were new territory, and getting the frontend and backend talking to each other in production (CORS, environment variables, DynamoDB permissions) took real troubleshooting time we hadn't budgeted for.
  • A subtle but important logic bug. Early on, fields chosen directly by the user (like a category picked from a dropdown) were incorrectly being tagged as AI-inferred instead of confirmed. Since the whole product's credibility rests on the provenance tagging being accurate, catching and fixing this mattered more than any UI feature.
  • Working within a small API budget. With a limited OpenAI budget, we had to be disciplined about caching test responses locally instead of hitting the live API on every UI tweak.
  • Deciding what not to build. Multi-source cross-validation, deeper PDF/vision reliability testing, and additional product categories were all on the table — we prioritized a smaller set of features that worked reliably over a longer list that might not hold up live.

Accomplishments that we're proud of

Building and deploying a working, end-to-end AI pipeline — from raw text input to a live, structured, provenance-tagged product record — solo, on a tight timeline, including learning and shipping on AWS infrastructure for the first time.

What we learned

That trustworthy AI output isn't about making the model more confident — it's about being honest when it isn't. Building the confidence/source tagging system taught us to treat "I don't know" as a first-class answer, not a failure state to hide.

What's next for CatalogIQ

  • Cross-source validation — comparing a product against multiple documents and flagging contradictions between them
  • Bulk catalog processing at real scale (hundreds to thousands of SKUs)
  • Deeper testing and hardening of PDF/DOCX/image ingestion
  • Direct integration hooks for PIM/ERP systems (SAP, Akeneo, Shopify B2B)

Built With

Share this project:

Updates