Inspiration

RitualProof began with a conversation about collagen.

A friend told me she had started taking a collagen supplement because the person who recommended it had used the same product for ten years and still looked almost exactly the same.

My first reaction was: but how do you know the collagen was responsible?

That question stayed with me.

People often take collagen powders, gummies, beauty drinks, functional beverages, and other beauty supplements for weeks or months. Yet when deciding whether to continue, they usually have little more than memory, personal feelings, testimonials, or selfies taken under completely different conditions.

Unlike a product with an immediate and visible effect, a long-term beauty routine is difficult to evaluate. People may forget what their skin looked like when they started, change several other parts of their routine, or interpret normal differences in lighting and camera angle as progress.

I wanted to create a more useful answer to the question:

Is this routine worth continuing?

Not a promise. Not a product claim. A better personal record.

What it does

Most skin analysis experiences answer:

What does my skin look like today?

RitualProof asks a different question:

How is my skin changing while I follow this routine?

RitualProof turns individual YouCam Skin Analysis results into a longitudinal tracking journey.

First, the user creates a focused tracking plan by recording:

  • The supplement or beauty-from-within routine they are following
  • The skin change they care about most
  • Whether they have not started, started recently, or already used the routine for a while
  • Their approximate product start date
  • Other skincare, sleep, diet, or lifestyle changes that could affect the comparison

The user then completes a first live YouCam scan. RitualProof records the returned skin-condition scores as a device-local starting reference. The scores and tracking context are saved in the same browser, while RitualProof does not save the user’s photo.

One scan is presented only as a starting point. No progress is shown yet.

When the user returns, they complete a second live YouCam scan. RitualProof retrieves the saved reference, calculates the change for the primary and supporting indicators, and explains what was observed.

This creates a real working loop:

  1. Create a tracking plan
  2. Complete a first live YouCam scan
  3. Save the starting reference
  4. Return for another live scan
  5. Calculate the change
  6. Interpret the comparison cautiously
  7. Continue building a pattern over future check-ins

RitualProof also separates Product Day from Tracking Day. Someone who began taking collagen one month before their first scan should not be shown a misleading “before-product baseline.” Their scan is instead described honestly as a current reference point from which future changes can be tracked.

Because the hackathon cannot wait several weeks to demonstrate a longer journey, RitualProof includes a separate example following Maya through Day 0, Day 14, and Day 28. Maya and her scores are clearly labelled as simulated example data. The personalized two-scan experience, however, uses two real YouCam analyses.

Why YouCam is essential

Without YouCam, RitualProof would be another subjective selfie diary.

The YouCam Skin Analysis API supplies consistent numerical skin-condition outputs that can be saved and compared across check-ins. RitualProof gives those individual measurements memory, product context, and a reason to return.

Instead of using the API only to generate a one-time result or recommendation, RitualProof uses it as the measurement layer in a longer consumer decision journey.

The API does not decide whether a supplement works. It provides the observations that make a more informed comparison possible.

How I built it

I built RitualProof as a responsive web application using React, Next.js, TypeScript, Vinext, Vite, and OpenAI Sites.

Photos are prepared in the browser before analysis. The application resizes and converts large or unsupported images when possible, then sends them through a server-side route to the YouCam Skin Analysis API. This keeps the API key out of the browser and out of the public source code.

After the first successful analysis, RitualProof stores the following information in browser local storage:

  • The selected routine
  • The primary skin focus
  • Product timing and approximate start date
  • Other reported routine changes
  • The YouCam starting scores
  • The date of the first recorded scan

A follow-up live scan reads this saved reference and calculates the score differences dynamically. The comparison is therefore based on the user’s two API results rather than a hard-coded result page.

I also designed different language for different starting situations:

  • Not started yet: a before-you-start reference
  • Started recently: a first recorded scan, not a true pre-product result
  • Used it for a while: a current reference point that cannot measure earlier changes

If a user reports changing skincare, sleep, diet, or another routine, that context remains visible in the result and the comparison is presented with extra caution.

I built RitualProof as a solo, non-technical participant, and this was my first time using Codex. I used Codex to help translate my product decisions into working code, understand the technical system, debug the API integration, and iterate quickly from user testing.

I remained responsible for the product concept, UX decisions, result language, testing, prioritization, and final experience.

Challenges I ran into

Turning a snapshot API into a tracking product

The central product challenge was that one skin scan cannot show change.

I needed to build the missing layer around the API: define the user’s question, save the first result, bring it back during a later scan, calculate the difference, and explain what that difference does and does not mean.

The solution was a device-local tracking loop that works without requiring accounts or a full database for the MVP.

Handling real-world photos

A photo that looks clear to a person may still be unsuitable for skin analysis.

During testing, I encountered images that:

  • Were too large to send reliably
  • Used formats that could not be decoded
  • Contained a face that was too small for analysis
  • Worked differently on mobile and desktop
  • Had cropped facial areas, shadows, or unsuitable angles

I responded by adding browser-based image preparation, clearer photo examples, face-position guidance, more useful error messages, and a retry flow that preserves the user’s tracking setup.

Demonstrating time honestly

A longitudinal product normally requires several weeks of use, but a hackathon demo cannot wait fourteen or twenty-eight days.

Rather than presenting invented personal progress, I separated the experience into:

  • A working personalized flow with two real YouCam scans
  • A clearly labelled simulated journey showing how a longer pattern could develop

This lets judges experience the technical loop immediately without pretending that time has passed.

Communicating evidence responsibly

Observed movement is not the same as proof of causation.

Lighting, angle, expression, makeup, device, sleep, diet, skincare, and other lifestyle changes can all influence a comparison. RitualProof therefore avoids claims such as “collagen improved your skin.”

Instead, it explains:

  • What changed
  • How large the movement was on YouCam’s scale
  • Whether only one comparison or a longer pattern exists
  • What other factors may have contributed
  • What the user should do at the next check-in

Accomplishments that I’m proud of

I am proud that RitualProof is not simply a YouCam API wrapper or a one-time result page.

The MVP completes the product’s core loop:

  1. A real YouCam scan creates the starting reference
  2. That reference survives a browser refresh
  3. A second real YouCam scan creates the follow-up
  4. RitualProof calculates the difference dynamically
  5. The result explains the observation without overstating what it proves

I am also proud that the experience remains honest about incomplete information. It distinguishes product timing from tracking timing, preserves other routine changes, explains the YouCam score scale, and clearly separates real user results from simulated example data.

Most personally, I am proud that I turned an everyday conversation into a working public product as a first-time, non-technical solo builder.

What I learned

I learned that integrating an API is only one part of building a trustworthy product.

A score becomes useful only when the product helps the user understand:

  • What it measures
  • What it should be compared with
  • Whether the photo conditions were similar
  • What changed between check-ins
  • What cannot be concluded from the result

I also learned that the strongest opportunity was not adding more skin metrics. It was adding time, context, and interpretation to the measurements already available.

Technically, I learned how client-side interfaces, server routes, environment secrets, image processing, browser storage, API responses, error handling, testing, and deployment work together.

From a product perspective, I learned to treat failed tests as user research. Each upload error or confusing screen revealed another assumption that the experience needed to explain.

What’s next for RitualProof

The next version would extend the current two-scan loop into a longer evidence journey through:

  • Optional accounts and cross-device history
  • Check-in reminders
  • Trends across several live scans
  • Routine adherence tracking
  • Photo-condition confidence signals
  • Same-image repeatability testing
  • Multiple tracking plans
  • Better controls for starting, stopping, or switching products
  • Carefully designed opt-in photo storage
  • Aggregated, privacy-conscious insights across routines and product categories

The long-term goal is not to tell every user that a beauty supplement works.

It is to help each person replace uncertain memory with a clearer record of how their skin changed, so they can make a more informed decision about whether to continue.

Built With

Share this project:

Updates

Submission history