Product case study · Internal tool

FaceSafe: removing a privacy risk instead of managing it

In human factors studies at Apple, every participant photo had to be blurred by hand, then every unblurred original had to be found and deleted. I spotted the risk, scoped the smallest tool that would remove it, and built it with AI. It went from a trial on my own phone to an internally hosted tool that about two teams at Apple now use across multiple projects.

My role
Product owner, solo: problem, scope, build, rollout
Users
Researchers on ~2 teams at Apple
Platform
iOS, fully on-device
Status
Hosted internally at Apple, used across multiple projects
TL;DR
  • Reframed the problem from “blurring is slow” to “an identifiable original should never exist.”
  • Scoped v1 to the real use case: one participant, headphones visible, nothing saved unblurred.
  • Built it with Claude, owning the spec, testing and every product call.
  • Trialled it on my own phone, demoed it to my team, ran testing and trials, and it’s now hosted internally and used by ~2 teams at Apple.
  • v2 built the app around a real session: study file naming, Next participant, auto-advancing orientations and Files app folders per study.
01 · The problem

A manual step that existed only to undo a risk

1
Shoot the study photo. Full face saved to the camera roll.
2
Blur each face by hand, one photo at a time.
3
Find and delete every unblurred original.
!
Any original that’s missed is participant PII left on a device.
The reframe

The real problem wasn’t that blurring was slow. It was that an identifiable photo existed at all. A faster blur tool, a checklist or a batch script would all still leave originals around to clean up. So the product goal became: the unblurred photo is never saved.

02 · Users and constraints

Who it’s for, and what the study demanded

Primary user

Researcher in session

Needs to capture photos fast without breaking the flow of a session with a participant.

Stakeholder

Study teams

Needs confidence that no participant PII persists anywhere after a study.

Hard constraint

The headphones must show

Participants wear the over-ear headphones being studied. The photos exist to show fit, so a full-face blur would make them useless.

03 · Requirements

Scoped to the real use case

Must have
  • Cover the face at capture, before anything is written
  • Save only the covered image
  • Keep hair, ears and headphones visible
  • Strip location and camera metadata
  • Run fully on-device
Should have
  • Live preview of where the cover will land
  • A manual fallback when no face is detected
  • A few cover styles and sizes, all fully private
Won’t do in v1
  • Multiple participants per photo
  • Video
  • Cloud sync or sharing
  • Android

Our studies have one participant in frame. Scoping to that kept v1 small enough to ship.

The product

One tap, and the only photo saved is already safe

FaceSafe camera screen with the face covered, a saved file-name toast, and ear and orientation chips
Camera. The cover tracks the face live, and every save confirms the exact file name.
FaceSafe session screen with participant ID, study, model, ear and a Next participant button
Session. Set participant, study, model and ear once. Next participant clears only the ID.
FaceSafe settings with editable orientations, auto-advance and Files app saving
Settings. Edit and reorder orientations, auto-advance after each photo, and save a copy to Files.
FaceSafe review screen after no face was detected, with an adjustable cover and Retake and Save buttons
No face detected. A review screen opens so the researcher can move and resize the cover, then save.
Files app folder for one study, with covered photos named by the study convention
Files app. One folder per study, every photo already covered and named.

Demo photos use my own face. No participant images are shown.

The settings, and why each one exists

Cover style
BlurPixelateSolid

All three permanently remove facial detail. Blur is pixelated first, then blurred, so the detail can’t be recovered. Solid is the most conservative. Teams pick the look that suits their report; none of the options is less private.

Cover size
TightStandardGenerous

Covers the eyebrows, eyes, nose and mouth. Each size grows height more than width, so even Generous stays clear of the headphones. Try it in section 06.

Save instantly when a face is found
On by default

One tap and the covered photo is saved, so the session keeps moving. Turn it off and every photo opens a review screen first. Photos where no face is detected always open for review.

Review screen
DragPinchTwist

Opens automatically when no face is detected, so the cover can’t be wrong or missing. The researcher moves and resizes the cover over the eyes, nose and mouth, then saves.

Privacy, shown in the settings, not buried
🔒 Unblurred originals are never saved📍 Location and camera data are stripped

These aren’t toggles. They’re fixed guarantees, listed in Settings so researchers can see exactly what the app promises.

Try it yourself

A live prototype, using your camera

The live prototype loads here when the page is viewed in a browser.

This web prototype recreates how FaceSafe behaves on the iPhone: live cover preview, capture, cover styles and sizes, and study file naming.

  • Start the camera and the cover follows your eyebrows, eyes, nose and mouth
  • Open settings (⚙) to switch Blur, Pixelate or Solid and Tight, Standard or Generous
  • Set the session, ear and orientation, and watch the file name change. Pick “front” to see L/R drop out
  • Tap the shutter to save a covered photo. Retakes get _2, _3
  • Bring someone else into frame: only the closest face is covered
🔒 Everything runs in your browser. Your camera feed is never recorded, uploaded or stored, and the only photo kept is the covered one, until you close the page.

Built for the web with an in-browser face-tracking model (MediaPipe). The iOS app uses Apple’s Vision framework.

04 · Key product decisions

The trade-offs I made, and why

Decision 1

Cover the features, not the whole face

Covers eyebrows, eyes, nose and mouth only. Less coverage than a full-face blur, but the photos stay useful as fit evidence, which is the whole reason they’re taken.

Decision 2

Instant save by default

Speed for the normal case. A review screen opens only when no face is detected, or if a researcher turns instant save off to check every photo.

Decision 3

Privacy by design, not by process

The original stays in memory and is never written to disk or Photos. There’s nothing to delete, so there’s nothing to forget to delete.

Decision 4

Few settings, on purpose

Three cover styles (Blur, Pixelate, Solid) and three sizes (Tight, Standard, Generous). Every option permanently removes facial detail, so researchers can adapt to the setup without ever choosing a less private result.

05 · Building with AI

Claude wrote the code. I owned the product.

I built FaceSafe with Claude. My job was the PM’s job: write the requirements, define what “done” meant, test it in realistic conditions, and decide what to change when the first version fell short (section 08). That split let me go from problem to a working app without waiting for engineering time.

06 · Under the hood

How it works, from shutter to saved photo

FaceSafe is a native SwiftUI app. All face detection runs on the phone with Apple’s Vision framework, so no image ever leaves the device.

1 · Detect
Vision finds face landmarks in each camera frame and draws the live outline.
2 · Size
The cover is built from the eyes, nose and mouth; the eyebrows set its top edge.
3 · Burn in
On capture, it re-detects on the full-resolution photo and burns the cover into the pixels.
4 · Save
Only that JPEG goes to Photos, with location and camera data stripped. The original stays in memory.
Core files
  • FaceMasker.swift: finds the face and sizes the cover
  • CameraModel.swift: camera session, live preview and capture
  • Models.swift: settings and the cover’s shape
  • SupportViews.swift: supporting screens, like the camera-permission prompt
  • FaceSafeApp.swift: the app’s entry point
Models.swift · a requirement, in code
enum Coverage {
  case tight, standard, generous

  // Width padding is kept small so the
  // cover stays clear of the headphones.
  var widthFactor: CGFloat {
    switch self {
    case .tight:    return 1.05
    case .standard: return 1.15
    case .generous: return 1.30
    }
  }
}

Every size pads width less than height, so “headphones stay visible” holds whichever option a researcher picks.

07 · Installing through Xcode

Getting it onto a phone, with no App Store

For the trial, I installed FaceSafe on my own iPhone straight from Xcode, using a free Apple developer account. No App Store, no review, no engineering ticket.

1 · Project
Create a new SwiftUI app in Xcode and add the source files.
2 · Configure
iOS 17 minimum, portrait only, plus camera and photo-library permission messages.
3 · Sign
Sign with a free Personal Team and turn on Developer Mode on the iPhone.
4 · Run
Build and run on the phone itself. The camera doesn’t work in the Simulator.
What went wrong on the way
  • Developer Mode didn’t appear on the phone until Xcode finished preparing the device.
  • A missing import caused six build errors; I worked through the fix with Claude.
  • Signing asked for passwords I had to figure out (Mac login vs. Apple ID).
The constraint that shaped rollout

Apps signed with a free account expire after a few days. That’s fine for proving the idea, but not for a team relying on it in studies. That limit is why the next step after the trial was a demo, testing with the team, and getting it hosted on Apple’s internal server.

08 · Pushing back on the first version

Where I pushed back on Claude’s first version

Claude’s first version handled the basic case, but it didn’t hold up in a real study room. I tested it in realistic conditions, named what was wrong, and told Claude what the right behavior had to be. These are the two changes I made.

FoundThe cover crept toward the headphone cups.
CauseWidth was sized from the eyebrow tips, which reach toward the temples.
FixWidth now comes from the eyes, nose and mouth; eyebrows only set the top edge.
FoundWith more than one face in frame, it could cover no face or the wrong one.
CauseThe first version wasn’t built for a real room, where a researcher or someone else can be in the background.
FixIt now targets the closest face, matching how study photos are actually framed.
09 · v2: Built around a real session

The next manual step: naming and sorting every photo

Once faces were handled, the next friction point was everything around the photo. Each one has to follow the team’s naming convention so it lines up with the study data, and researchers shoot several angles per participant, back to back:

ParticipantID_StudyName_Model_Ear_Orientation.jpg
Set up once per participant
  • A session bar on the camera screen holds participant ID, study and model
  • Next participant keeps the study and model and clears only the ID
  • Ear (L / R) and orientation chips sit right on the camera screen
  • A live preview shows the exact file name before you shoot
Keep the session moving
  • After each photo it moves to the next orientation automatically (you can turn this off)
  • The orientation list is editable in Settings: add, delete and reorder. The order sets the chips
  • Retakes get _2, _3, so nothing is overwritten
  • A saved toast confirms the exact file name
Files land where they belong
  • A copy goes to the Files app, in a folder per study (On My iPhone › FaceSafe › study name)
  • Photos can rename files on export, so the Files copy keeps the exact name when AirDropped or copied to a Mac
When there’s no face to find
  • Top and back shots often show no face at all
  • When no face is detected, a review screen opens: move and resize the cover, then Retake or Save
  • Nothing is saved until a cover is in place
Why it matters

v1 removed the privacy cleanup. v2 removes the naming and sorting cleanup. Each rule came from watching how sessions actually run, not from the first spec. Try it in the live prototype above: set the session, take a few photos and watch the orientation move on and the names update.

10 · Outcome

From my phone to ~2 teams at Apple

Trial
Installed it on my own phone with a free Xcode build, which expires after a few days, to prove it worked in real sessions.
Demo
Demoed it to my team to show the workflow it replaces.
Test
Ran testing and trials with the team before relying on it in studies.
Adopted
Now hosted on Apple’s internal server, so teams can install it without a personal build.
~2
Teams at Apple using it, across multiple projects
0
Unblurred originals saved, by design
2 → 0
Manual steps per photo (blur, then delete)
11 · What’s next

How I’d measure it, and where I’d take it

Metrics I’d track
  • Share of study photos captured through FaceSafe
  • Detection miss rate (captures that need manual review)
  • Time from capture to a usable photo
  • PII incidents, with a target of zero
Next bets
  • Flag low-confidence detections for a quick second look
  • Export straight to the study’s shared folder
  • Bring it to more research teams at Apple
12 · What I took away

The best fix removed the step

  • Speeding up a risky step still leaves the risk. Designing it out removed the cleanup work entirely.
  • Tight scope came from the real use case, not a feature list.
  • Building with AI shifted my work to spec, testing and judgement, which is where product work lives anyway.

Case study by Apoorva Revankar. Demo photos use my own face; no participant images or internal Apple materials are shown.