sana

We look at our face every day and still don’t understand it.

Comment

Inspiration

This was about 2 months before hackathon even announced....

I’m 18. I had never seen a dermatologist.

Neither had my father, who is 47. I wasn’t even sure there was one near where I live.

But my skin was constantly annoying me. Acne. Uneven tone. Rough texture. Dark circles. And zero understanding of why any of it was happening. So I did what everyone does when they don’t know what to do: I went to YouTube.

And the problem was always the same.

Every video had an answer.

Use this product. Stop eating that. Wash face twice a day. Exfoliate. Moisturize. Sleep more.

It all sounded like it will work. It rarely felt real.

Because skin is not a single-variable system. Two people can have the same visible symptom and completely different causes. Skin is influenced by everything: environment, climate, UV exposure, humidity, pollution, diet, sleep, routine, products, habits, stress, and probably a bunch of things we don’t even measure properly yet.

So I tried the “obvious next step.”

I looked for a dermatologist.

The consultation I found was around ₹15,000 — roughly $157 at the time. For me, that was not “expensive.” It was impossible. That was half a semester of tuition.

So I did what I always do when something is out of reach.

I tried to replace it with software.

I used Grok. I used other skin analysis tools. They could detect visible issues. They could label things. But the experience always ended the same way: a snapshot, followed by generic recommendations.

So I started experimenting.

I took photos of my face and asked AI to analyze specific regions. Sometimes it worked. Sometimes it confidently misread post-acne marks as active acne. Sometimes it treated redness as a generic “issue” without context. Sometimes it gave advice that sounded correct but had no causal explanation tied to my skin.

And I kept thinking:

What do I actually know about my own skin?

I could see the symptoms.

But I couldn’t see the system behind them.

So I kept going. Week after week. Hoping patterns would emerge.

They didn’t.

Then, about two months later, I found the Perfect Corp skin analysis hackathon.

I claimed the credits. Opened the playground. Uploaded my face.

Waited.

11 seconds.

Result came back.

At first, it was just data. Just numeric scores in json. Measurements. Interesting, but not meaningful yet.

So I did something simple.

I downloaded everything. Copied the JSON. And fed it into Grok.

That was the moment it clicked.

It started connecting signals across regions instead of isolating them; moisture levels, texture shifts, environmental influence, and pattern correlations that suddenly made the skin feel less like scattered symptoms and more like a connected system.

It felt like the system was finally describing skin as a system, not a checklist.

That was exciting.

But it also exposed the next problem immediately.

It was still a single moment in time.

No memory. No trajectory. No evolution.

So I started building.

On August 8, I began building Sana from scratch on my iPad.

I named it Sana because, in my understanding, it means healthy.

I started mapping everything that could affect facial skin. I ended up with 200+ factors—diet, sleep cycles, UV exposure, humidity, pollution, stress, product interactions, and behavioral patterns. Obviously impossible to model fully in a hackathon while also doing college.

So I cut it down.

Hard.

I kept only what could actually be made real: skin measurements, environment, weather, UV, routines, products, habits, incidents, and user context.

And I built around one idea:

This should not be a report.

It should be a ritual.

Scan every day.

See what changed.

Accumulate history.

Build a baseline.

Understand skin over time.

Not in one shot.

I even started changing my own behavior while building it.

I stopped eating certain foods just to see if my skin trajectory changed. I stopped using a face scrub daily after Sana’s agent explained how repeatedly stripping the skin barrier can increase irritation and make recovery harder.

Then I gave it to a few friends.

One of them didn’t ask about the model.

Didn’t ask about the backend.

He just asked:

“How do I get this on my phone?”

That was the moment I knew it was real.

What it does

Sana is a personal skin intelligence system that turns daily scans, routines, and environmental conditions into a continuous understanding of your skin over time. Instead of treating each scan as an isolated result, it builds a living timeline that connects what is happening today with what happened before, and explains why.

It combines Perfect Corp’s skin analysis with an autonomous AI agent that can remember past states, track changes, and reason across time. Each scan becomes part of a growing personal model of your skin, enriched with context like weather, UV, humidity, pollution, habits, and product usage.

The result is not just detection, but understanding: what your skin is, what your normal looks like, and how it responds to change.

How I built it

I didn’t optimize for features. I optimized for one thing: understanding.

I didn’t want Sana to say:

“You have acne. Use this product.”

That already exists everywhere. 

I wanted it to answer something harder:

why is skin behaving this way, right now, in this context?

That requires memory. It requires continuity. It requires comparison across time. 

So I built it around a loop: A scan is not data. It’s an observation. A product reaction is an observation. Sleep, weather, UV exposure, routine changes are observations.

Over time, those observations form a model.

So Sana is built around daily analysis, not one-time reports.

A scan happens. A few lightweight questions are answered. The system compares it with history, updates skin state, and decides what actually matters today.

Not everything.

Just what matters now.

That’s why the home screen has a Daily Focus.

It compresses everything into a small set of signals: what changed, what likely caused it, and what should be considered next.

The AI agent sits on top of this system.

It can search the web, use tools, access private memory, maintain a file system, track goals, log incidents, build protocols, schedule actions, and interact with MCP services.

But the key design decision was this:

The skin history is not “remembered” by the LLM. It is stored structurally, programmatically, as a real evolving dataset. The agent reads it. Reasons over it. Extends it.CIt does not hallucinate memory. I also deliberately constrained scope. I had 200+ factors mapped out. I didn’t implement all of them yet though. Because trying to model everything in a hackathon produces something that looks smart but behaves weak. So I chose depth over breadth.

I also left out:

  • full account system
  • deeper calendar integrations
  • native mobile app
  • expanded environmental tracking
  • notification infrastructure

Because the core had to work first.

The loop had to be real:

scan → understand → remember → compare → advise → repeat

Everything else is optional.

Challenges

The hardest problem was not integrating Perfect Corp’s API—it was making the output usable for reasoning over time.

The API returned highly granular, region-based facial metrics (like texture, moisture, pigmentation, and pore visibility), but they were inconsistent across scans due to small variations in lighting, angle, and face positioning. Early on, this made the system unreliable: two scans of the same face could produce slightly different distributions, which completely broke any attempt at trend detection.

At first, I tried to “fix” this by smoothing the data post-hoc, but that created a worse issue—false stability. The system would hide real changes in skin condition because it was over-correcting noise.

So I had to redesign the pipeline properly.

Instead of treating each scan as a final truth, I introduced a normalization layer that converts raw region outputs into a consistent internal representation anchored around relative change, not absolute values. This allowed the system to compare “direction of change” (improving, worsening, stable) rather than relying on exact numbers that were inherently noisy.

On top of that, I built a temporal alignment step that groups scans into short windows and compares them against a rolling personal baseline instead of a global one. This was critical because skin is not static across users—it is only meaningful relative to its own history.

The second major challenge was the agent memory layer. Initially, I tried letting the LLM directly interpret past scans, but it quickly became unstable: context windows were inconsistent, and the model would overfit to recent scans while ignoring older but more important trends.

The fix was to separate memory from reasoning. I moved all historical skin data into a structured store and forced the agent to query it explicitly through tools instead of relying on prompt injection. This made the system slower in design, but dramatically more reliable in output.

Together, these changes turned Sana from a “scan-and-report tool” into a system that can actually track skin evolution over time, which was the entire point of the product.

What I’m most proud of

What I’m really proud of is that this system doesn’t feel like a tool anymore — it feels like something that can grow beyond what I originally built it for.

Because Sana is not just a skin app. It’s a system that can scale into something much larger: a real-world, continuously learning model of human skin across millions of users.

And that’s the part that excites me the most.

Today, it starts with skin. But skin is just the entry point.

If you think about it, skin is one of the most personal biological systems we have. It reacts differently for every single person — not just in visible ways, but in how it responds to environment, weather, UV exposure, pollution, sleep, stress, diet, and even small daily habits. It’s almost like a fingerprint that is constantly changing.

And right now, most of what exists in this space is based on small, controlled conditions — lab tests, isolated studies, or single snapshots of a moment in time. But real skin doesn’t exist in a lab. It exists in chaos. In real weather. Real routines. Real life.

That’s what this system is trying to capture.

A living dataset of how skin actually behaves in the real world.

And once you start collecting that at scale — across thousands, then millions of users — something new becomes possible. You stop seeing isolated cases and start seeing patterns that were never visible before. You can understand how skin evolves across environments, how it reacts to lifestyle changes, and what truly causes improvement or breakdown over time. We will finally know the actual secret for korean skin.

That’s where the real potential is.

And it doesn’t stop at skin.

Because once you have a system that can track and reason about one biological surface over time, you can extend that same idea to other domains — health patterns, early disease signals, recovery cycles, even personalized medicine. Not in a generic “AI healthcare” way, but in a deeply individual way where every recommendation is grounded in your history, not population averages. (I am thinking of medication synthesizer that can synthesize derma creams or tablets and stuff in the moment.)

And that’s where it gets even more interesting.

Because eventually, this kind of understanding could even contribute to things like synthetic biology and prosthetics, where understanding how real skin behaves under different conditions could help design synthetic skin that actually reacts like human skin. Not just visually, but functionally. Temperature, pressure, healing, sensitivity — all of it.

That’s a long-term vision, but the foundation starts here.

Even the internal system I built — the graph-based reasoning layer — is something I’m personally most excited about. It’s not just an AI agent. It’s a system that takes raw observations, connects them, and actually computes meaning over time. It evaluates changes, builds relationships between variables, and slowly turns scattered data into something structured and understandable.

Honestly, that part feels more powerful than the UI or even the agent itself, because it’s where the “thinking” actually happens.

And on a personal level, this project already changed how I behave.

It made me more aware of my own skin, my habits, and how small decisions compound over time. It’s not just something I built — it’s something I started using to understand myself better. It helped me make better product choices, adjust routines, and actually see the impact of those changes instead of guessing.

And that’s when I realized something important:

If a system is designed well, it doesn’t just give answers — it changes behavior effortlessly.

That’s why I focused so much on making the experience frictionless. Because habits don’t form through complexity. They form when the action is almost invisible, and the feedback is immediate and meaningful.

So yeah, what I’m most proud of isn’t a single feature.

It’s the fact that this started as a simple idea about skin, and slowly turned into a system that can collect real-world biological data, learn from it over time, and potentially scale into something much bigger than I originally imagined.

And we’re still at the beginning.

What I learned

This was the first time I really tried to build something for real users. Something simple enough that people could use it without me standing next to them, explaining every feature. I didn’t even tell my friends what the application was about. I just gave it to them and said, “try this.”

It was a bit of a funny experiment, honestly.

They opened it and immediately thought it was a weather app because of the front widget. And in a way, that actually made sense — until you understood the intention behind the product. Watching them interact with it without context was the first time I really saw my own assumptions break in real time.

I just observed quietly, noted everything down, and started improving the UI based on what confused them or slowed them down. For the first time, I wasn’t building in isolation. I was actually reacting to other humans using something I made.

Before this, I was always building for myself. I never needed external input because I already knew how I wanted things to work. But this time was different. This time, the system had to make sense to someone else without explanation.

That shift taught me a lot about user experience — especially how little things that feel obvious to a builder can be completely invisible or confusing to a user.

On the technical side, I also ran into something I hadn’t dealt with before: graph-based reasoning and structured relationships between data points, without relying on an LLM to just “figure it out” for me. Building that layer of connections manually — and making it stable — was harder than I expected. It forced me to think more rigorously about how information actually flows and connects in a system.

It’s still early. Very early. But I can already see how this becomes powerful once machine learning models are layered on top of it properly. The long-term goal is to build a more accurate, real-world understanding of skin and other body signals — not just visually, but in a quantitative, measurable way. Something that can actually represent change over time instead of just describing a moment.

I also learned a lot about AI agents in practice, but not in the “new concept” sense. I had already been building and experimenting with them before this. So this wasn’t new territory for me — it was more about applying them in a constrained, real product environment and seeing where they actually help versus where they just add noise.

But the most important learning wasn’t technical.

It was realizing how different it feels when something you build stops being “yours” and starts being used by someone else. That changes everything, from how you design flows, to how you think about clarity, to how aggressively you simplify.

And I think that’s the biggest shift for me from this project:

I stopped building just to express ideas.

And started building so other people could actually use them.

The line I’d put on the poster

You are amazing. Let’s be healthy.

What's next for sana

Next, I’m going to focus on building the graph-based architecture and its dynamics. I’ll start by collecting structured skin-related data and then train a machine learning model on top of it. The idea is to learn relationships between different signals—so if the model detects that certain patterns are correlated, it can connect those events and form meaningful links.

This will allow Sana to move from just tracking changes to actually understanding them. So when the agent retrieves past information, it won’t just see isolated scans, it will recognize related events and understand how they influence each other over time.

After that, I’ll work on making the system faster, more efficient, and improving the agent’s reasoning through better system prompts and deeper research in dermatology and skin science.

I also want to refine the core architecture further and build a privacy-first data collection pipeline, where we only store numerical metrics and structured signals—no images, no sensitive raw data. Everything stays abstracted, secure, and privacy-preserving.

Once the core system is solid, I’ll explore integrations with other applications like fitness and lifestyle tracking tools to enrich context even further.

And finally, the last step will be building a mobile application, once everything underneath is stable, fast, and truly reliable.

Built With

Share this project:

Updates

Submission history