[DUPLICATE - PLEASE DISREGARD] SkinSense AI

Production-grade LLM resilience demonstrated through AI skin analysis. Three fallback layers. Zero downtime.

Comment

⚠️ THIS IS A DUPLICATE SUBMISSION — PLEASE DISREGARD

This entry was created by accident. The actual submission is at: https://devpost.com/software/skinsense-ai-nogj30

Inspiration

Every production app using LLMs faces the same nightmare: when your primary model goes down, your product breaks. SkinSense AI solves this with a 3-layer resilience architecture that guarantees a response — even when multiple AI providers fail simultaneously.

The skin analysis use case is intentionally chosen to stress-test the system: it requires both vision AI (image understanding) and text AI (personalized recommendations), exposing the architecture to two independent points of failure.

What it does

  1. Upload a selfie → Qwen Vision analyzes 8 skin dimensions: acne, wrinkles, pores, moisture, radiance, dark circles, pigmentation, and texture.
  2. DeepSeek generates personalized skincare recommendations based on the analysis.
  3. If DeepSeek fails → automatic failover to Kimi (sub-second switch).
  4. If both LLMs fail → Rule-Based Engine kicks in, built from dermatology guidelines using the actual skin scores, ensuring users always get actionable, personalized advice — not generic filler.
  5. Real-time Dashboard exposes the routing chain, fallback events, per-model latency, and cost savings vs GPT-4 — the kind of observability production teams actually need.

How we built it

Built in a single day using Next.js 15 + TypeScript. The core is a 3-layer LLM router: Qwen Vision (via OpenRouter) handles image analysis and returns 8-dimension skin scores as JSON. DeepSeek then generates personalized recommendations. If DeepSeek times out (8s threshold), the system automatically falls over to Kimi. If both fail, a Rule-Based Engine generates personalized advice derived directly from the skin scores — not generic responses.

The real-time Dashboard tracks every API call, records which layer handled each request, measures latency per model, and calculates cost savings vs GPT-4 baseline. Deployed on a US server via PM2 + Nginx with SSL.

Challenges we ran into

Perfect Corp's free API quota ran out mid-development. Switched to Face++, which hit concurrency limits on the free tier. Finally landed on Qwen Vision via OpenRouter — more reliable and cost-effective for this use case.

Getting the Rule-Based Engine to feel genuinely personalized (not like a fallback) required mapping dermatology guidelines to specific score thresholds so every recommendation references the user's actual skin data.

Accomplishments that we're proud of

The Rule-Based Engine is the part we're most proud of. When all AI providers are down, users still receive advice tailored to their specific scores — not a generic error message or placeholder text. This is what "zero downtime" actually means in practice.

Also proud of the Dashboard: it makes the invisible visible. Every routing decision, every fallback event, every cost calculation is exposed in real time — the kind of observability that production teams need but rarely build.

What we learned

LLM resilience is an infrastructure problem, not an afterthought. Most apps treat fallback as "show an error message." Real resilience means the user never knows a failure happened.

Vision AI and text AI fail independently — building a system that handles both failure modes simultaneously forced cleaner architecture decisions throughout.

What's next for SkinSense AI

Expand the Rule-Based Engine with more dermatology guidelines and ingredient interaction checks. Add MCP server integration so the resilience layer can be used as a standalone module in other products. Long-term: package the 3-layer LLM router as an open-source library any Next.js project can drop in.

Built With

Share this project:

Updates