Inspiration
Estheticians and med spas don't sell single facials — they sell series: six sessions, spaced weeks apart, with a home regimen in between. But the record of that series lives in the practice's software, if it exists at all. The client — the person whose face it is — leaves with nothing she can look at: no baseline, no progress, no proof the series is working.
The tools that do measure skin progress are built for the practice, not the client, and priced that way: VISIA-class imaging systems run $15,000–$25,000, staff-operated, in-office only. Even Perfect Corp's own Skincare Pro ($199–$299/month, iPad-only) keeps the report inside the practitioner's CRM, has no client-owned take-home record, no structured series object, and no way for the client to scan at home before she arrives.
There are 10,488 med spas in the US; 81% are single-location, and 73% of their patients are repeat patients — people mid-series, wondering if it's working. We built the missing piece: the series itself, carried by the client.
Perfect Corp sells the scan. Lead-gen apps sell the lead. EstiSeries sells the finished series.
What it does
EstiSeries is a treatment-series companion for estheticians, med spas, and their clients, built on the YouCam AI Skin Analysis API:
Client self-scan, at home, before the visit. The practitioner shares a link or QR code (generated in the app). The client opens it on her phone — no install, no account — reads and accepts a five-point consent, and takes one guided photo. Photo problems come back as coaching, not dead ends: the flow maps YouCam's real error codes (too dark, face too small) to plain fixes and a retry. Instant plain-language report. Overall score, skin age, skin type, and all scored concerns translated into banded, human language — including the honest parts. If a concern went down since baseline, the timeline shows it as it is. Pre-visit Brief for the practitioner. Before the client walks in, the practitioner opens her brief: headline scores, top focus areas, biggest gains since baseline, and generated talking points — including the flat areas to name honestly. Plan Builder. The practitioner turns the brief into a series: templates (1–12 sessions), focus concerns with per-concern notes, an AM/PM regimen, and retail products with a running total — then shares the plan to the client's view. A series timeline the client owns. Baseline → session 3 → session 6, every scan with per-concern deltas, branded to her practitioner. It lives on the client's phone, not locked in the practice's CRM.
Everything is framed, in the product's own words, as what it is: "Cosmetic skin analysis for consultation and progress tracking. This is not a medical diagnosis." A selfie cannot match VISIA-class UV/cross-polarized imaging, and we never claim it does — this is guidance and progress tracking a solo practitioner can actually afford.
How we built it
Three surfaces, one data contract:
Practitioner app — Flutter/Dart for Android: three screens (Setup & branding, Pre-visit Brief, Plan Builder). Practice branding (name, practitioner, accent color, scan-link QR) re-skins both the app and the client flow. Client web flow — zero-framework HTML/CSS/JS: welcome → five-checkbox consent gate → guided capture with an error-code coaching loop → instant report → series timeline. Backend — a zero-dependency Node.js service that holds the YouCam API key server-side (it never ships in the app or the page) and runs the asynchronous S2S flow: register file → upload → create analysis task (SD tier, 16 concerns) → poll → map the response into the shared ScanResult shape (overall, skin age, skin type, 15 concern scores) that every surface renders.
A SkinAnalysisService interface sits in front of the backend with two implementations — Live and Demo. Demo mode serves a complete seeded series (one studio, one client, three scans across a six-session series) so the entire product — consent, coaching loop, report, brief, plan, timeline — can be evaluated end-to-end with no key and no network. The web flow asks the backend which mode it's in (GET /health) and drives the same code either way; in demo mode it rehearses the coaching loop through the backend's own simulated-error endpoint, which mirrors YouCam's real error surface.
Challenges we ran into
Credential reality vs. documentation. Our first API credential turned out not to be a recognized API key — the API answered 401 InvalidApiKey, and we verified that with a direct registration call before burning a single analysis unit (units charge only on success; we spent 0). The demo/live split behind one interface is what kept the project fully testable while that's resolved — the architecture absorbed the failure instead of the schedule. Strict photo rules. The API rejects dark, small, or turned faces with specific error codes. We turned that surface into a feature: the capture step is a coaching loop keyed to the real codes, so a bad photo becomes "face a window and try again," not a failed check-in. Results expire. Analysis results live on the provider's side for 24 hours. The demo data model already treats the series timeline as our stored record — the production version caches every result into the client's series at scan time. Camera access on plain HTTP. Phone browsers refuse camera access on non-secure origins, which we hit testing on a home LAN. The flow degrades gracefully to a demo-photo path; production hosting is HTTPS (see What's next).
Accomplishments that we're proud of
The whole loop, working: consent → guided scan → report → practitioner brief → series plan → client-owned timeline, across three surfaces sharing one honest data contract. Honesty as a design rule. The demo series includes two concerns that declined — and the timeline shows them, with copy that names flat areas plainly in the practitioner's talking points. Progress tools that only show good news aren't trusted; this one is built to be believed. A real consent gate. Five explicit, separately-checked statements — including third-party processing, the 24-hour provider deletion, and "this is not a medical diagnosis" — and Continue stays disabled until all five are checked. Zero-dependency discipline. The backend and the client flow have no framework and no build step; the only service dependency is the YouCam API itself.
What we learned
The scan is not the product — the workflow around the scan is. The sponsor's own tooling proves the white space: when the platform leaves "progress tracking and personalized reports" to the builder, the builder's job is to find the object the platform doesn't have. For this market that object is the series — and the person who should hold it is the client. We also learned to build against the error surface first: the coaching loop, the consent copy, and the demo/live split all came from taking the API's failure modes seriously on day one.
What's next
Live scan proof the moment the validated API Console key is in place (the wiring is done; it's a key swap and one scan). HTTPS hosting for the client flow so phone cameras work in the real world, plus result caching into the series record. Multi-client roster for practitioners (the demo ships with one client) and per-practice scan-credit bundles. Productize for the 81%: single-location studios at an accessible per-location price with bundled scan credits — the tier the $199–$299/mo incumbents don't serve.
