Skip to content
AI-Native PM

A real incident

A women's safety app left its photos and messages open to anyone with the link, and the chapters next door are the seven layers that would have caught it.

01 / 09
A real incident

In July 2025 the Tea app's photo storage sat open to anyone with the link, and a stranger wrote a script that walked the folders and downloaded 72,000 images, including 13,000 verification selfies and government IDs.

Two class-action suits followed within days, and a second open database spilled 1.1 million private messages. The app's matching and posting worked fine. The failure sat one layer down, in storage nobody had locked.

TechCrunch and 404 Media, 2025, on the Tea breach

02 / 09
What happened

The images lived in a storage bucket that anyone on the internet could read.

THE STORAGE BUCKET

The exposed storage lacked basic security protections, including authentication and encryption.

No login was ever required.

The file paths were not secret, only unlisted, and the bucket even allowed directory listing. One script that walked the folder tree pulled every file in minutes.

03 / 09
What actually failed

The app's features worked. Three choices in the layers underneath did not.

The storage bucket allowed public reads, so files meant to be private were reachable straight from the browser.

Sign-in gated the app but never gated the data, so records sat open behind no check.

Nothing watched the storage, so the first anyone heard of the leak was a post on a message board.

A better model would not have prevented any of it, because none of the gaps were in a model. They were in the layers the build was assembled from.

04 / 09
The pattern

Open storage and leaked keys are the common way AI-era builds break.

23.8M

secrets pushed to public GitHub in 2024, up 25% on the year

70%

of secrets leaked in 2022 are still valid credentials today

The dangerous layer is rarely the clever part of a build. It is the plumbing: a key in the browser, a database with no lock, a config nobody read.

GitGuardian, State of Secrets Sprawl 2025

05 / 09
The one idea

Every product runs on the same seven layers, and a feature is only as safe as the layer you forgot to check.

The screen, the server, the API between them, the stored data, the rented computer, the sign-in, and the monitoring. Miss one and that is where the incident starts.

06 / 09
What this part builds

Four of the seven layers, one skill each.

The screen

See a UI as three materials and steer edits, knowing everything here is public.

The data

Pick the smallest storage that fits, and keep stored records off the live prompt.

The sign-in

Split who-you-are from what-you-may-do, and write the spec that gates access.

The monitoring

Name the worst silent failure, the signal for it, and where the alert lands.

07 / 09
The objection worth answering

"The coding tool handles the layers. That is the whole point of using it."

The tool builds each layer, but it does not decide which one holds your users' IDs or whether that store is locked. Tea's storage was reportedly generated with AI help and shipped without an audit, and the tool will build an open bucket just as readily as a closed one if nobody says which to make.

Understanding a layer is not writing its code. It is knowing that anything the browser can reach is public, that a database needs its own lock, and that the choice the tool cannot make for you is the one that breaks.

08 / 09
What actually fixes it

Each gap in this story has a chapter that closes it.

Private files served to anyoneFrontend

Treat everything the browser can reach as public, and keep private records off it.

A store with no lockData

Keep records behind the server, separated from the per-turn prompt.

Sign-in that gates the app, not the dataAuth

Write the three-line spec that gates access, and apply it at the data, not just the door.

No signal it brokeMonitoring

Write one sentence: the worst silent failure, the signal, and where the alert lands.

Check the layer before you approve it, and the open bucket never ships.

09 / 09
From story to part

Every gap in this story is a chapter here.

Seven chapters walk the layers every product is built from, from the screen down to monitoring, so you can trace any build end to end, name where each feature must run and what it costs, and steer what a coding tool builds instead of rubber-stamping it. No engineering background needed.

Start with chapter one