Inspiration

I absolutely love skincare. But even after spending hours researching products, I still struggle with one question: What will actually work for my skin?

Recently, during a skincare sale, I found myself comparing serums, moisturizers, ingredients, and reviews for hours.

I knew what I wanted. Healthier skin, more hydration, fewer breakouts, and that glowy, dewy finish.

But I still couldn't decide what to buy.

Here's why.

I've experimented with skincare for a while. Vitamin C made my skin itch. Azelaic acid broke me out. Snail mucin, on the other hand, seemed to work wonderfully for me.

Now imagine finding a promising new product during a sale. It has glowing reviews, beautiful packaging, and claims to be perfect for your skin.

But buried somewhere in its long ingredient list is Ascorbyl Glucoside, a vitamin C derivative.

You might not even recognize it.

You could end up purchasing a product without realizing it contains an ingredient related to something you've previously reacted to.

Different forms of vitamin C have different properties, and reacting to one doesn't mean you'll react to all of them. But wouldn't it be useful to know about that connection before spending your money?

That's when I realized the problem isn't finding skincare products. It's finding products that make sense for you.

And this problem goes far beyond my own experience.

The problem is bigger than we think

A 2021 survey by Hong Kong's Consumer Council interviewed 1,650 women about their skincare shopping habits.

49% reported owning skincare products that had remained unopened for more than a year.

The report also found that discounts and brand hype can encourage unnecessary purchases and product stockpiling.

Think about it. We spend money on products that promise amazing results, only for some of them to sit unused on our shelves.

Sometimes we buy more than we need. Sometimes we don't know how to fit a product into our routine. Sometimes the product simply doesn't meet our expectations.

And sometimes, we discover that our skin doesn't respond well to it.

With opened skincare often difficult to return, an unsuitable purchase can mean wasted money and an uncomfortable experience.

Everyone's skincare journey is different

There are people who are complete beginners.

They don't know whether their skin is oily, dry, combination, or normal. They don't know which ingredients to look for or how to build a basic routine.

Then there are people like me.

We've experimented with multiple products. We know a little about skincare ingredients. We follow skincare trends and read reviews.

But we still don't always know what genuinely suits our skin.

Two people can have similar skin types and completely different experiences with the same product.

And the confusion doesn't end with skincare.

What if I want a dewy finish but have an oily T-zone? Is my undertone warm, cool, neutral, or olive? Which skin tint should I choose? Which moisturizer will work under my makeup?

Beauty is personal. So why are we still shopping through generic recommendations?

What I wanted to build

I didn't want another skin analysis app that simply tells users they have redness, visible pores, or oily skin.

Knowing what your skin looks like is only the beginning.

The real question is: What should I do next?

What should I buy? Which ingredients should I look for? What should I avoid? Why might a product not suit my needs? What if I'm just starting skincare?

I wanted to create something that could connect all these questions.

Something that understands your skin, remembers your past product experiences, recognizes ingredients you might overlook, considers your beauty preferences, and helps you make more informed decisions.

Something useful whether you're buying your first moisturizer or your twentieth serum.

That's how derm//os was born.

Shop by your face, not by the hype.

A personalized skincare and beauty shopping companion that combines AI skin analysis, ingredient history, product matching, and virtual try-on.

Because your skin is unique, and your skincare decisions should reflect that.


What it does

derm//os turns one selfie, your skincare history, and your beauty goals into a personalized skincare basket.

Instead of stopping at a skin scan, it connects what the analysis finds to actual shopping decisions.

Here's the experience.

1. One selfie to understand your skin

Upload a selfie or start with one of our prepared demo profiles.

Using YouCam's AI Skin Analysis API, derm//os examines different facial regions and measures concerns including oiliness, moisture, pores, acne, redness, radiance, and texture.

For example, your T-zone might be oily while your cheeks are normal.

Instead of treating your entire face as one skin type, derm//os considers these differences when choosing products.

Your results are explained in simple language:

  • T-zone: Oily
  • Cheeks: Normal
  • Moisture: On the low side
  • Pores: Somewhat visible

There are no confusing numerical skin scores in the user-facing experience.

The measurements help determine what your skin may need, including hydration, oil control, and suitable product textures.

2. Your skin goals matter too

Not everyone wants the same results.

Some people want glowy, dewy skin. Others want a natural look or a matte finish.

derm//os asks three quick questions:

  1. What's your desired finish? Glowy/dewy, natural, or matte.
  2. What's your budget?
  3. What have you tried before?

These answers influence the final recommendations.

For example, someone with an oily T-zone who wants a dewy finish shouldn't automatically receive a heavy moisturizer for their entire face.

The app considers both what their skin may need and what they want their skin to look like.

3. A skincare history that remembers your experiences

This is one of the features that makes derm//os different.

Skin type alone cannot tell the complete story.

Users can record ingredients or products that previously worked well or caused problems.

For example:

  • "Vitamin C made my skin itch."
  • "Azelaic acid broke me out."
  • "This moisturizer worked well for me."
  • "I already own a cleanser I like."

The app uses that information when evaluating new products.

Our ingredient-checking system can recognize exact ingredient matches, related ingredient families, and repeated patterns across previous products.

For example, a new product might contain Ascorbyl Glucoside, which belongs to the vitamin C family.

If the user previously reported discomfort with a vitamin C product, derm//os highlights that connection and recommends reviewing the ingredient and patch-testing.

It doesn't assume that every vitamin C derivative will cause the same reaction.

Another example:

Contains Alcohol Denat., found in 2 of 2 products that previously made you itch, sting, or burn.

This is a pattern worth reviewing, not proof that the ingredient caused the reactions.

Your previous experiences become useful information for your next purchase.

4. A personalized skincare basket

Once derm//os understands your skin needs, history, finish preferences, and budget, it builds a basket from the store's available products.

The basket covers specific jobs such as:

  • Cleanser
  • T-zone moisturizer
  • Cheek moisturizer
  • Sunscreen or skin tint

Each product recommendation explains three things.

From your face: Why it matches your skin's measured needs.

From your history: Whether its ingredients match any previous concerns or preferences.

Matches your finish: Why the texture or finish aligns with the look you want.

The app also explains where and when to use each product.

And there's something else.

If you already own a product that fills the same purpose, derm//os can tell you to skip buying another one.

The goal isn't to fill your cart with unnecessary products.

It's to help you find what you actually need.

5. What we skipped, and why

Most shopping platforms explain why you should buy something.

derm//os also explains why a product wasn't recommended.

A product might be skipped because:

  • It contains an ingredient you've chosen to avoid.
  • Its ingredients overlap with products that previously bothered you.
  • Its texture doesn't match your facial-zone needs.
  • It doesn't match your desired finish or budget.
  • The available shade doesn't fit your estimated shade family.
  • Its ingredient list is incomplete.

Every skipped product comes with a clear reason.

For example:

Made for dry skin, but your T-zone reads oily.

Or:

Ingredient list incomplete. We can't check everything against your history.

An incomplete ingredient list is marked as unknown rather than being treated as a successful ingredient check.

And when no conflict is found, we don't claim the product is guaranteed safe.

We want people to understand a recommendation, not blindly trust it.

6. Undertone estimation and beauty virtual try-on

Skincare and beauty often overlap.

You might understand your skincare routine but still struggle to find the right foundation shade or finish.

derm//os uses YouCam's AI Facial Color Tones Analyzer to obtain skin-color information.

Our custom undertone engine converts that information into the CIELAB color space and estimates shade depth and undertone categories including warm, warm-neutral, neutral, cool-neutral, cool, and olive.

These are rule-based estimates, not undertones directly measured by YouCam.

We then use YouCam's AI Makeup Virtual Try-On API to preview foundation looks on the user's face.

Users can compare matte and dewy finishes side by side.

This helps connect skincare preparation with the beauty look someone actually wants.

The virtual try-on requires a live scan. The public demo clearly labels prepared scan data and displays a placeholder where a live render would appear.

7. Check an ingredient list from another store

Found a promising product somewhere else?

With Paste Any Label, users can paste its ingredient list into derm//os.

Our engine checks that list against their saved skincare history using the same rules applied to products in the store's catalogue.

It can highlight recorded conflicts, ingredient-family connections, repeated patterns, or missing information.

This means your skincare history remains useful even when you're considering products outside our demo catalogue.

8. A beginner-friendly starting point

Not everyone knows skincare terminology or has previous product experiences to record.

derm//os includes a dedicated beginner path.

Users can skip the history questions and start with a gentler selection of products.

The system favors simpler routines, fewer strong actives, and products without certain commonly avoided ingredients such as fragrance, essential oils, and Alcohol Denat.

It also explains what each product does and how to introduce it gradually.

You don't need to understand skincare before using derm//os.

9. A helper for unexpected breakouts

One of the most frustrating skincare questions is:

"My skin suddenly broke out. What changed?"

Our breakout helper starts by asking about symptoms such as itching, burning, or swelling.

It then reviews products introduced or changed during the previous 2 to 8 weeks.

It helps users inspect possible triggers, explains when purging might be relevant, and identifies a product to consider pausing.

It does not diagnose the exact cause of a breakout.

For painful, cystic, persistent, or concerning breakouts, the app recommends consulting a dermatologist.

10. A simple plan for starting new products

A good shopping experience shouldn't end at checkout.

After building a basket, derm//os creates a product introduction plan.

The plan recommends a seven-day patch-testing period and introducing new products one at a time, with 14 days between additions.

It starts with gentler products and provides downloadable calendar reminders.

This helps users keep track of what they've introduced rather than starting several unfamiliar products simultaneously.

11. Check-ins and saved profiles

Users can optionally compare a later skin scan with their first scan.

Instead of displaying arbitrary improvement scores, the app describes the measured differences in plain language.

With an optional account, users can also save:

  • Their preferred finish and budget
  • Ingredient preferences and product experiences
  • Products they already own
  • Personalized baskets and start plans
  • Previous scan results

They can download their saved data or delete their account.

The goal is to make future shopping decisions easier without asking users to start from scratch every time.

All products and brands in the current prototype are fictional. derm//os supports shopping decisions and does not diagnose skin conditions or guarantee individual product compatibility.


How we built it

We didn't want derm//os to be a basic interface that calls a skin analysis API and displays the result.

We wanted the analysis to influence real product decisions.

Our architecture follows a connected pipeline:

Selfie → Skin measurements → Personal needs → Ingredient history → Product matching → Personalized basket → Virtual try-on → Start plan

The system combines three YouCam APIs with custom Python decision engines.

1. Integrating three YouCam APIs

YouCam API Purpose
AI Skin Analysis v2.1 Measures skin type across facial regions and concerns such as oiliness, moisture, pores, acne, redness, radiance, and texture
AI Facial Color Tones Analyzer Returns skin-color data used by our custom undertone and shade-depth estimation engine
AI Makeup Virtual Try-On Renders foundation looks for comparing matte and dewy finishes

Each API has a specific role.

Skin Analysis identifies measurable facial characteristics.

Skin Tone provides color information for shade matching.

Makeup Virtual Try-On helps users visualize a base product on their own face.

The recommendation system connecting these APIs is built by us.

2. Selfie capture and preprocessing

The frontend uses MediaPipe Face Landmarker to guide users while capturing a selfie.

Before spending any YouCam API units, the backend performs a free image precheck.

It checks whether:

  • A face can be detected.
  • The head position is acceptable.
  • The image is sufficiently illuminated.
  • The face can be cropped for analysis.

The preprocessing system re-encodes the image from its pixels, removing metadata before upload.

For additional reliability, the server-side MediaPipe processing runs in an isolated child process so a native-library failure cannot crash the main API server.

3. Our custom skin-needs engine

The needs engine translates skin measurements into skincare requirements.

For example:

Oily T-zone → oil-control requirement → lightweight textures and suitable ingredient targets

Lower cheek moisture → hydration requirement → hydrating ingredients and suitable moisturizers

These mappings are stored in a curated, versioned needs.json file.

This separation allows us to update recommendation logic without changing the YouCam integration.

4. Our undertone estimation engine

The undertone-1.0 engine processes the skin-color values provided by YouCam.

It converts them into CIELAB, a color space used to describe color in terms of lightness and chromatic components.

Our rules then use properties such as hue angle and lightness to estimate undertone and shade depth.

The current categories are:

  • Warm
  • Warm-neutral
  • Neutral
  • Cool-neutral
  • Cool
  • Olive

These categories come from our own documented thresholds, so we clearly label them as estimates.

If color analysis isn't available, the user can answer a quick fallback question.

5. Ingredient history and conflict checking

The cartcheck engine evaluates each product against the user's saved history.

It follows a consistent decision ladder.

Result Meaning
Blocked The product contains an explicitly avoided or doctor-confirmed ingredient
Repeats a pattern An exact ingredient repeatedly appears in products the user reported as unsuitable
Patch-test first A weaker potential conflict or related ingredient-family match exists
No recorded conflicts Nothing in the available history matched
Unknown The ingredient list is incomplete and cannot be fully checked

We also built a patterns engine.

It compares ingredients found in products that previously bothered a user with ingredients found in products that suited them.

This helps identify repeated patterns without making medical claims about causation.

Our ingredient-family mappings and history chips support synonyms and related ingredient forms.

The same ingredient-checking logic is used for both our catalogue and the Paste Any Label feature.

6. The basket recommendation engine

Our basket engine combines:

  1. Skin needs by facial zone
  2. User history and ingredient preferences
  3. Product ingredient lists
  4. Product categories and textures
  5. Desired beauty finish
  6. Estimated shade family
  7. Budget
  8. Products already owned

The engine filters available products and selects items for specific routine jobs.

Every selection and rejection is accompanied by an explanation.

The recommendation process uses deterministic, versioned Python rules.

A language model does not make the final product selections.

This makes the decisions reproducible and easier to test.

7. Other custom engines

Component Responsibility
findings-1.0 Converts measurements into simple explanations
needs Maps skin measurements to needs, textures, and ingredient targets
undertone-1.0 Estimates undertone and shade depth
basket Builds a personalized basket and explains selections and skips
cartcheck Checks catalogue ingredients against user history
patterns Identifies repeated ingredient patterns
chips Manages ingredient-history options and family synonyms
pastecheck Checks ingredient lists copied from other stores
lookfor Explains what to look for on product labels
startplan Creates the patch-testing and introduction schedule
triage Powers the breakout helper

An optional local language layer using Ollama can help interpret free-text history or rephrase explanations.

It is disabled by default, and any generated output is checked before being shown.

The application works without it.

8. Our technology stack

Frontend

  • React 18
  • TypeScript
  • Vite
  • Progressive Web App support
  • MediaPipe Face Landmarker
  • Responsive CSS Grid and container queries
  • Vercel deployment

Backend

  • Python 3.12
  • FastAPI
  • Docker
  • MediaPipe
  • SQLite for local development
  • Supabase PostgreSQL for deployment
  • Render deployment

Authentication and storage

  • Supabase Auth
  • PostgreSQL
  • Server-side authentication-token verification
  • User-scoped database queries

Optional accounts let users preserve their skincare preferences, product history, existing products, baskets, and scan results.

9. API implementation and credit protection

The integration includes YouCam's file-upload workflow, asynchronous tasks, polling, and task deletion.

Key endpoints include:

  • POST /s2s/v2.0/file
  • POST /s2s/v2.1/task/skin-analysis
  • POST /s2s/v2.0/task/skin-tone-analysis
  • POST /s2s/v2.0/task/makeup-vto
  • POST /s2s/v2.0/task/delete
  • GET /s2s/v2.0/credit/feature-cost
  • GET /s2s/v1.0/client/credit

A complete live basket using the configured features has an estimated cost of 34 API units:

Operation Units
Skin Tone Analysis 20
Skin Analysis with 8 concerns 12
Two Makeup Virtual Try-On renders 2
Total 34

The backend fetches current feature costs and account balance before live requests.

We also implemented:

  • Free image prechecks
  • Live-scan passcode protection
  • Daily and total credit limits
  • Reserved credit balance
  • Rate limiting
  • Prepared demo data that consumes no YouCam units

The public demo clearly marks prepared results as demo data.

10. Privacy by design

Facial images are sensitive, so we designed derm//os to avoid retaining them in our application database.

During a live scan, the image is processed temporarily, sent to YouCam for analysis, and deleted from our backend after processing.

We also request deletion of the corresponding YouCam task and its assets.

Our database stores relevant measurements, preferences, and saved shopping information rather than facial photos.

Pasted ingredient lists are not saved.

Users with accounts can export their information or delete their accounts.

11. Testing and continuous integration

The latest documented project snapshot, dated November 2, 2026, includes:

  • 1,182 passing backend tests, with one skipped
  • 238/238 rule benchmark cases
  • Responsive layout checks across 10 screen sizes
  • TypeScript validation
  • Production build checks
  • A custom claim linter
  • GitHub Actions CI

Our self-written rule benchmark verifies that the decision engines behave according to their specifications.

It is not an independent clinical evaluation or a measurement of YouCam's accuracy.

Our claim linter also checks user-facing text for unsupported promises, including terms such as "cures", "proven", and "guarantee".

This helps us maintain clear boundaries between measurement, inference, and recommendation.


Challenges we ran into

1. The live API response was different from what we expected

During our first real Skin Analysis integration test, the returned skin-type data didn't match the structure our parser expected.

We initially expected a combined object containing whole-face, T-zone, and U-zone information.

The live response returned separate items for individual facial regions.

We rewrote the parser to handle both formats and added automated tests for each.

Lesson: Always test against real API responses, not just expected structures.

2. Regular selfies were rejected because of face angle

A slightly tilted selfie failed the Skin Tone API's angle requirements.

This was frustrating because we wanted the experience to work with an ordinary phone photo.

We addressed the issue by using the most lenient supported angle configuration, adding a free MediaPipe head-pose check, and running Skin Tone before the other paid analysis.

If color analysis still fails, users can answer one fallback question instead of abandoning the flow.

We wanted to reduce repeated photo attempts and unnecessary API spending.

3. Translating skin measurements into useful recommendations

A skin analysis might show that someone's T-zone is oily.

But that alone doesn't explain which moisturizer they should buy.

We had to connect the measurements to suitable ingredient targets, textures, and specific routine jobs.

The challenge became more complicated when we added user history, budget, preferred finish, and products already owned.

We solved this by separating skin interpretation, ingredient checking, and basket construction into independently testable engines.

The API provides the measurements. Our decision system turns those measurements into shopping actions.

4. Understanding reactions without making unsupported claims

Skincare is complicated.

If several products that bothered someone share an ingredient, that doesn't prove the ingredient caused their reaction.

Formulation, concentration, and other ingredients can also matter.

We needed to make past experiences useful without pretending to diagnose ingredient sensitivities.

Our solution was to distinguish explicit avoidance preferences, repeated patterns, related ingredient families, incomplete information, and cases with no recorded conflicts.

Instead of claiming a product will definitely cause a reaction, derm//os explains what it found and why that information deserves attention.

5. Working with limited API credits

Every live analysis consumes API units.

We couldn't afford to repeatedly call paid endpoints while developing and testing every feature.

So we built a demo mode that uses prepared scan values, automated rule tests that require no network access, and safeguards around live requests.

This allowed us to test our recommendation logic independently of the paid API integration.

6. Keeping the experience simple

Behind the scenes, derm//os considers facial zones, skin measurements, ingredient lists, previous product experiences, finish preferences, budgets, and shade estimates.

But users shouldn't have to understand all that complexity.

We focused on three questions:

What does my skin need?

What should I buy or avoid?

Why?

The challenge was making the system technically detailed without making the user experience complicated.


Accomplishments that we're proud of

1. Going beyond a basic skin analysis

The biggest accomplishment is connecting the scan to actual decisions.

We didn't want to build something that simply displays skin scores.

derm//os uses skin measurements, shopping preferences, ingredient history, and product information to build an explainable basket.

The real value comes from what happens after the scan.

2. Building a personal ingredient-history system

We created a system that remembers ingredients and products users have previously tried.

It can identify exact ingredient matches, related ingredient families, and repeated patterns in products that bothered users.

This makes recommendations more personal than matching products to skin type alone.

3. Explaining what not to buy

Our app doesn't only display selected products.

It also explains which products were rejected and why.

This includes ingredient conflicts, unsuitable textures, budget mismatches, missing shade options, and incomplete ingredient lists.

We believe knowing why something was skipped is just as valuable as knowing why something was recommended.

4. Combining three YouCam APIs into one shopping experience

We integrated AI Skin Analysis, Skin Tone Analysis, and Makeup Virtual Try-On.

Each contributes to a different part of the user's journey.

The measurements and renders are combined with our custom engines to support a connected experience, from skin understanding to product selection and beauty visualization.

5. Creating a system that works for beginners and skincare enthusiasts

Someone completely new to skincare can skip complicated history questions and receive a simpler starting selection.

Someone with years of product experience can record detailed preferences and past reactions.

The same application adapts to the information each user provides.

6. Supporting smarter purchasing decisions

derm//os can recognize when users already own a suitable product for a routine job.

It can suggest skipping another purchase instead of automatically filling the basket.

This supports our goal of helping people buy more thoughtfully.

7. Engineering, testing, and privacy

We're proud of building more than the visible interface.

Our latest documented results include 1,182 passing backend tests, 238 successful rule benchmark cases, automated claim checking, and layout validation across 10 screen sizes.

We also built photo-handling protections, user-scoped account access, API credit controls, and a demonstration mode that works without paid requests.

8. A complete, usable prototype

derm//os includes a guided selfie flow, understandable scan findings, personalized baskets, explanations for skipped products, ingredient-label checking, beginner support, a breakout helper, saved profiles, start plans, and virtual try-on integration.

These features work together around one goal:

Help the user understand their skin and know what to do next.


What we learned

1. Knowing your skin type isn't enough

A skin scanner can tell someone that their skin is oily or that their moisture reading is low.

But what they really want to know is what to do with that information.

A useful skin analysis should lead to a useful next step.

2. Personal experiences matter

Two people with similar skin types might respond differently to the same product.

We learned that a useful recommendation system must consider history, preferences, and existing routines alongside measured skin characteristics.

3. Ingredient lists are harder to understand than they look

An ingredient can appear under a technical name that users don't immediately recognize.

For example, someone familiar with the term vitamin C might not realize that Ascorbyl Glucoside belongs to the same broader ingredient family.

This inspired us to develop ingredient-family matching and clear explanations instead of relying only on the words users recognize.

4. Recommendations are more useful when they're explainable

A product recommendation shouldn't feel like a random suggestion.

Users should know whether it was selected because of their facial-zone needs, their ingredient preferences, their budget, or their desired finish.

We learned to make explanations part of the core product rather than an afterthought.

5. Not knowing something is different from inventing an answer

Skin analysis and ingredient matching have limitations.

A scan cannot establish every skin condition, and an ingredient-list comparison cannot predict exactly how someone's skin will react.

We learned to make those limits useful by flagging incomplete information, showing related ingredient patterns, and offering practical next steps.

6. Real-world API integration requires flexibility

Live API responses, selfie requirements, and limited credits shaped many of our engineering choices.

We learned to validate inputs before paid requests, handle unexpected response formats, provide fallbacks, and test decision logic separately from external services.

7. Good design makes complicated technology feel simple

Our recommendation system involves several inputs and decision engines.

But the user experience should feel straightforward.

Upload one selfie. Answer a few questions. Understand the basket.

The complexity should be handled by the application, not passed on to the user.


What's next for derm//os

Our vision is to make derm//os a personal skincare decision companion that works wherever people shop.

1. Integrate real beauty retailers

Our current prototype uses a fictional catalogue containing 19 products.

The next step is supporting real retailer inventories with ingredient lists, product categories, textures, finishes, available shades, and prices.

We envision a "Build My Basket" or "Check Against My Skin" button that retailers could integrate into their online stores.

That would let shoppers use their skin needs and history at the moment they're making a purchase.

2. Expand ingredient intelligence

We plan to add more ingredient families, synonyms, and ways to record product experiences.

We also want to improve how the application recognizes patterns across products someone liked or disliked.

Any future pattern analysis would still distinguish possible associations from proven causes of reactions.

3. Make product check-ins more useful

We want to extend check-ins beyond comparing two skin scans.

Future versions could incorporate product introduction dates, routine changes, reported symptoms, and personal feedback.

For example, if someone started a new moisturizer and noticed repeated discomfort afterward, derm//os could help them review that timeline.

The goal is to help users understand their routines without requiring constant selfies.

4. Build richer beauty experiences

We want to expand the connection between skincare and makeup.

Future possibilities include more detailed skin-tint matching, additional virtual finishes, and product recommendations that connect skincare preparation with makeup preferences.

Someone who wants a glowy base while managing an oily T-zone should be able to explore products that support both goals.

5. Help people use what they already own

One of our long-term goals is to reduce unnecessary skincare purchases.

We want to make it easier to build routines around products users already have, identify missing routine essentials, and avoid buying duplicates.

Sometimes the best shopping advice is not to buy anything new.

6. Make the system useful across shopping platforms

We want derm//os to become more than a standalone app.

Our long-term goal is a reusable decision layer that connects skin analysis, ingredient history, product catalogues, and beauty preferences across different shopping experiences.


I started derm//os because I love skincare, but I was tired of spending hours researching products and still feeling unsure about what to buy.

I wanted something that would remember what I had tried, recognize ingredients I might overlook, understand my skin, and consider what I actually wanted to achieve.

Something that could help a complete beginner choose their first moisturizer and help a skincare enthusiast make sense of their next serum purchase.

Not another app that tells you what you can already see in the mirror.

An app that helps you understand what to do next.

Because your skin is unique. Your experiences matter. And your next skincare purchase deserves more than a guess.

derm//os

Shop by your face, not by the hype.

Built With

Share this project:

Updates

Submission history