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.
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.
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.
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.
- 01frontend → POST /styling/verdict (DolphJS)
- 02DolphJS creates Outfit { status: pending } → pushes job to Redis
- 03returns { outfitId, status: processing }
- 04job-worker picks up job → calls Gemini vision
- 05worker → PATCH /styling/outfits/:id/complete (internal)
- 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