case study · AI · Distributed system

Charis

A wardrobe operating system for smarter dressing.

Role
Solo: product, design, frontend, backend, infra
Timeline
Aug – Sep 2026, built in public on YouTube
Status
Live
Links
live ↗code ↗demo ↗
Stack
Next.jsDjangoDolphJSBullMQRedisPostgreSQLGeminiRAGDocker

Digitise your closet once, then get AI outfit verdicts, outfits generated from what you actually own, trip packing lists and honest wear analytics.

01

The problem

Most people own more clothes than they wear. The decision of what to put on happens in a rush, in front of a mirror, with no memory of what was worn last week or what actually goes together. Existing wardrobe apps are glorified photo albums: you catalogue, and then nothing happens.

Who it’s for

People who care how they look but don’t want to think about it every morning, and people packing for trips with several events and dress codes.

02

Goals & constraints

Goals

  • Make the wardrobe useful after it’s digitised. Every item should feed decisions.
  • Give verdicts that explain themselves (what clashes, how confident the model is), not just a thumbs up.
  • Never block the UI on slow AI calls.
  • Use real algorithms where they solve real product problems, not LeetCode bolted on.

Constraints

  • AI calls are slow and occasionally fail, so the product has to stay responsive.
  • Built solo, on a deadline, while also in school.
  • Free-tier hosting, so services had to be cheap to run and easy to restart.

03

Approach

  1. 1.

    Start from the morning decision

    I mapped the flow backwards from the moment someone stands in front of the mirror. That gave four core features: a styling verdict for an outfit you’re considering, an outfit generator for when you have no idea, a trip planner for multi-day events, and analytics so the app learns what you really wear.

  2. 2.

    Split the system by who owns what

    Django owns the data backbone: wardrobe items, wear logs, trips, social records. DolphJS owns the intelligence layer: occasions, verdicts, combo generation. A BullMQ worker owns everything slow. Each piece can fail or be redeployed without taking the others down.

  3. 3.

    Make the slow path feel instant

    Every AI request returns immediately with a ‘processing’ record. The worker does the work, patches the result back into the owning service, and the frontend’s poll resolves. The user sees progress, never a frozen spinner.

04

Architecture

Four services (Next.js frontend, Django + DRF core, DolphJS styling service, Node + BullMQ worker) sharing Postgres with separate schemas, plus Redis.

  1. 01frontend → POST /styling/verdict (DolphJS)
  2. 02DolphJS creates Outfit { status: pending } → pushes job to Redis
  3. 03returns { outfitId, status: processing }
  4. 04job-worker picks up job → calls Gemini vision
  5. 05worker → PATCH /styling/outfits/:id/complete (internal)
  6. 06frontend poll resolves → verdict rendered

05

Key decisions

A queue instead of synchronous AI calls

Neither backend ever waits on a model. That one decision made the app resilient to model latency and let me retry failed jobs without the user re-submitting.

Snapshotting outfits as JSON for social

Shared outfits are stored as a snapshot of their items, so a friend sees the full look and the AI verdict even if the poster later deletes a piece from their wardrobe.

Redis-keyed notification dedupe

Reminder notifications write a Redis key with a one-hour expiry. If the same alert is queued twice inside that window, it’s dropped. Small thing, big difference to how the app feels.

RAG grounded in a curated style library

‘Complete the look’ suggestions retrieve from hand-written notes on dress codes, fabrics, colour theory and fit, instead of letting the model improvise fashion advice.

↳

DSA in the code

Real algorithms, solving real product problems.

Backtracking + constraint pruning

styling-service · combos.algorithms.ts

Generates valid outfits from N items without brute-forcing every permutation.

Weighted graph scoring

styling-service · verdict.algorithms.ts

Colour and formality compatibility are weighted edges; an outfit’s score is a traversal over that graph.

Greedy set-cover approximation

backend · tripplanner/algorithms.py

Builds a season- and formality-aware capsule that covers every event with the fewest pieces.

Sliding-window aggregation

backend · analytics/aggregations.py

Wear frequency over time and cost-per-wear, computed from real wear logs.

!

Challenges

Keeping four services in sync

Internal callbacks between the worker and DolphJS needed their own auth and idempotency so a retried job couldn’t double-write a verdict.

Making AI output trustworthy

Raw verdicts were confident and vague. Forcing structured output (what works, what clashes, a confidence score) and reranking algorithmic candidates with vision made results feel earned.

✓

Outcome & lessons

  • Shipped and live, with every phase documented as a build-in-public video.
  • A real distributed system: 4 services, a job queue, RAG, and four algorithms doing product work.

What I learned

  • Queues are a UX decision as much as an infra one.
  • Service boundaries are easiest to draw around data ownership.
  • DSA reads differently when it’s solving your own product’s problem.

What’s next

  • Wear-pattern insights pushed as weekly notes
  • Mobile capture flow for faster digitising
next projectSabi→