SecondSight

AI-powered quality control for small maker businesses - inspect from four angles, catch defects early, and reduce bad batches.

Comment

Inspiration

The main inspiration came from the gap between large manufacturers and small makers. Big factories can invest in expensive computer vision and industrial QA systems, but independent makers, Etsy sellers, and small print shops usually inspect products manually.

I wanted to explore whether AI could close that gap by turning a simple four-photo workflow into a usable quality-control process. I was also interested in building something that felt grounded in the real world: instead of another purely digital assistant, I wanted to build a tool that helps people make and ship better physical products.

What problem your app solves and why you built it

Problem

SecondSight helps small 3D-print makers catch defective products before they ship. Small makers often rely on manual visual checks, which are inconsistent, difficult to track over time, and can lead to wasted material, bad batches, returns, and lost revenue.

Industrial quality-control systems are typically too expensive and too complex for solo makers or small shops, so I built SecondSight to give them a lightweight, browser-based, AI-assisted inspection workflow using only four product photos.

Why I built it

I wanted to build something that brings AI into a real physical workflow, not just a digital productivity task. The maker economy has many small businesses producing real products, but most of them do not have access to affordable quality-control tools. SecondSight is my attempt to make quality control more accessible, repeatable, and practical for small-batch production.

What it does

The app guides users through a structured inspection using top, bottom, left, and right views of a 3D-printed item, then analyzes those views, classifies the item as Pass, Review, or Fail, and logs the result into batch history and analytics.

The real inspection pipeline uploads the four images to Supabase Storage, sends them through a Supabase Edge Function, and analyzes them with Gemini 2.5 Flash. The result is normalized, checked with deterministic rules, and then saved into Supabase for dashboards and batch tracking.

How we built it

I built SecondSight as a responsive MeDo-generated web app, then extended it into a real inspection system with backend services and AI analysis.

Frontend

The app includes:

  • landing page
  • dashboard
  • batch history
  • inspection workflow
  • settings
  • result views
  • downloadable report flow

Backend and data

I used:

  • Supabase for database and app state
  • Supabase Storage for inspection and reference images
  • Supabase Edge Functions for server-side inspection orchestration

AI pipeline

The app:

  1. collects four uploaded images of the same item
  2. uploads them to storage
  3. sends them to an Edge Function
  4. analyzes them with Gemini 2.5 Flash
  5. applies deterministic guardrails
  6. returns a structured QA result
  7. saves the result into batch history and analytics

Quality-control logic

The intelligence layer combines:

  • real AI image inspection
  • rule-based guardrails
  • optional reference-image comparison

This helped make the results more reliable than using a purely unconstrained model response.

Challenges we ran into

One of the biggest challenges was moving from a polished prototype to a genuinely working inspection pipeline. It was easy to make the app look complete, but much harder to make the intelligence layer real and reliable.

Key challenges included:

  • replacing mocked inspection results with actual image-based analysis
  • handling image upload and storage permissions correctly
  • debugging Supabase Row Level Security and storage access
  • fixing save-flow issues between frontend state and database schema
  • making the AI output robust even when model responses were not perfectly formatted
  • separating demo data from real inspection data so analytics stayed trustworthy
  • reducing friction in the inspection flow with image quality pre-checks and better upload feedback
  • keeping the app responsive and polished on both desktop and mobile

Another challenge was making the system believable. I did not want the app to overclaim industrial precision, so I added deterministic guardrails and safer fallback behavior to keep the quality verdicts more trustworthy.

Accomplishments/Features

  • a responsive inspection workflow for desktop and mobile
  • 4-view product inspection using top, bottom, left, and right photos
  • real AI-based defect analysis of uploaded images
  • deterministic QA guardrails to reduce overconfident results
  • optional reference-based comparison using known-good product images
  • batch creation and batch-linked inspection history
  • dashboard analytics including defect trends, fail rate, recent inspections, and estimated loss
  • downloadable inspection reports
  • image quality pre-checks before paid AI analysis
  • demo/live data separation so analytics are not misleading

What we learned

This project taught me a lot about both product design and AI system design.

Product lessons

I learned that a strong hackathon project is not just about flashy features. It needs:

  • a clear user problem
  • a focused scope
  • a believable workflow
  • a polished end-to-end experience

Technical lessons

I learned how important it is to combine model output with deterministic logic. Pure AI responses can be brittle, especially when they need to feed directly into app logic. Adding structured output constraints, safe normalization, fallback handling, and guardrails made the system much stronger.

MeDo lessons

I also learned that MeDo works best when used iteratively. Instead of asking for everything at once, breaking the project into phases made it much easier to build, test, debug, and refine.

Personal takeaway

The biggest takeaway was that AI can be much more compelling when it supports a real-world operational workflow. SecondSight started as a concept, but by the end it became a working tool that connects inspection, storage, analytics, and reporting in one system.

How you structured conversations with MeDo

I used MeDo in a phased, iterative way rather than trying to generate the whole product in one step.

Phase 1

I used MeDo to build the product foundation:

  • landing page
  • dashboard
  • batch history
  • seeded demo data
  • responsive layout

Phase 2

I expanded the app with the guided 4-photo inspection workflow for:

  • top
  • bottom
  • left
  • right

I also added the inspection result interface.

Phase 3

I connected the workflow to real app state by adding:

  • batches
  • saved inspections
  • batch detail pages
  • dashboard updates

Phase 4

I refined the app with:

  • settings
  • loading, empty, and error states
  • responsive cleanup
  • overall demo polish

After the main product shell was stable, I used additional MeDo conversations to:

  • replace the mocked QA flow with a real intelligence layer
  • harden reliability
  • separate demo data from real data
  • fix Supabase storage and save-flow issues
  • add report download
  • add client-side image quality checks
  • improve reference image upload progress

This multi-turn structure let me use MeDo both as a rapid builder and as an iterative debugging and refinement partner.

The most impressive code or feature MeDo helped create

The most impressive part MeDo helped create was the real multi-view inspection pipeline.

SecondSight does not just show a static UI. It takes four uploaded photos of the actual item, stores them in Supabase Storage, sends them to a Supabase Edge Function, analyzes them with Gemini 2.5 Flash, applies deterministic guardrails, and returns a structured quality-control result with:

  • verdict
  • severity
  • confidence
  • findings
  • per-view analysis
  • recommended action

The app then saves that result into the selected batch and updates dashboard analytics automatically.

A second standout feature is the optional reference-based mode. Users can create product profiles with known-good reference images, and those reference images are included as extra context during inspection when available.

How you used plugins or APIs to extend functionality

I extended the MeDo-built app with a real backend and AI analysis pipeline.

The app uses:

  • Supabase for database, storage, and app state
  • Supabase Storage for inspection and reference image files
  • Supabase Edge Functions for server-side processing
  • Gemini 2.5 Flash for multimodal image understanding
  • MeDo gateway / MeDo-driven workflow to integrate the intelligence layer into the app flow

Uploaded inspection photos are stored in Supabase Storage, passed into the Edge Function, analyzed by Gemini, normalized into a structured result, and then written back into the app’s inspection history and analytics pipeline.

What's next for SecondSight

The next step for SecondSight is to move from a strong hackathon MVP into a more production-ready quality-control tool for small maker businesses.

Short-term roadmap

In the near term, I want to improve reliability, usability, and reporting by:

  • expanding testing with more real-world 3D-print defect examples
  • improving AI consistency across repeated inspections
  • refining defect classification for issues like warping, layer shift, stringing, and base lift
  • making inspection reports more polished and export-friendly
  • improving performance and image handling for faster analysis
  • adding stronger batch-level insights and trend tracking over time

Product expansion

After the hackathon, I want to expand SecondSight beyond single-item inspection into a more complete quality workflow, including:

  • better product-profile management
  • stronger reference-based comparison
  • smarter batch-level anomaly detection
  • support for repeated inspections across production runs
  • more actionable analytics for failure patterns and estimated loss -add an option to increase the number of angles used for QA

Broader vision

While the current version is focused on small 3D-print makers, the long-term vision is to extend the same workflow to other small-batch maker products where visual quality matters.

The bigger goal is to make AI-powered quality control accessible to small businesses that cannot afford expensive industrial inspection systems.

Built With

Share this project:

Updates

Submission history