Designing file discovery around how people actually remember.
On a team collaboration app, every shared file eventually vanished into the chat thread it was posted in. I rebuilt discovery around the file itself — so a document stays findable no matter which conversation it started in.
- Role
- Lead UX Designer — end to end: research, IA, interaction, rollout
- Timeframe
- 2022–24
- Context
- MelpApp — messaging, calls and workspace chat · live in ~150 companies
- Team
- 6 designers I led · PM · founder · platform engineering
Figures from the product's own Firebase analytics, measured before vs. after release. Ask for more in conversation.
Workspace homePinned canvases, recent assets, live rooms.
Files & discoveryUploaded by me, shared with me, inbound shares.
Advanced searchWhere, type, who and when — not exact filenames.
Share sheetDestinations, access level, reshare and link expiry.
Asset detail & permissionsWho holds access, at what level, with an audit trail.
Live threadThe conversation a file came from, context intact.
Spaces & projectsTeams, canvases and milestones in one place.
Live canvas & huddleCritique on the canvas, with the call attached.
Activity & approvalsAccess requests, syncs and mentions in one queue.
The finished app, screen by screen — every file a team ever shared, in one place, with the conversation it came from still attached.
Every team had the same quiet ritual: scroll up.
When the chat becomes a filing cabinet.
Someone shared a file last week, the conversation moved on, and now finding it means combing back through hundreds of messages — or just asking them to send it again. Files rode along inside conversations, which felt natural until a thread got long. Then the document you needed was somewhere in there, unsearchable, often re-uploaded two or three times by people who couldn't find the original.
The product had quietly become an archive of files without ever becoming a system for managing them. People didn't lose files because the app lacked a feature — they lost them because the app's only model for a file was “a thing that happened in a conversation.”
- 01Files buried inside long conversation histories.
- 02No single place to see everything a team had shared.
- 03The same file uploaded again and again across different chats.
- 04No ownership or edit control once a file was out in a thread.
- 05Search that only matched filenames — so you had to remember exactly what something was called.
They remembered the file. Never the chat.
“Nobody remembered which chat a file was in. They remembered the file.”
Once a document had been shared, people expected to find it on its own terms — by what it was, who sent it, when — not by reconstructing the conversation it came from. That single observation moved the problem from “improve message history” to “give files a home of their own.”
We weren't fixing search inside chat. We were giving files a place to exist.
The obvious fix was a folder tree.
The easy answer was a conventional file explorer bolted onto the side. Here is what I ruled out before arguing for something structurally different.
- Better in-chat search
Cheap to ship — but it still asks people to remember the conversation first.
- A separate file explorer
Familiar, and it splits attention between “where I talk” and “where my files live.”
- Pin or star important files
Puts the work on the user, at the one moment they don't yet know a file matters.
- Every option kept the file a side effect of a message. The mental model stayed broken.
- A folder tree would have created a second place to lose things — and a second copy to reconcile.
- The problem sat below the interface, in what a file is in the data model.
A workspace, not a folder. One file, two ways to find it.
Every file lives in two places at once: by conversation — the thread it came from, context intact — and by workspace, in folders, for people who organise. Files grouped by conversation preserve the why; the same files in a structured workspace serve the people who think in folders. Nobody had to choose, and nothing was stored twice.
Right instinct, wrong reading. There was only ever one file. Upload it from any channel and it stays a single canonical copy; by conversation and by workspace are two lenses onto it, never a second copy.
Same reframe: one storage path, two visibilities — not two systems. What finally landed with the founder wasn't architectural but commercial: this was the change most likely to lift retention, because people would stop losing their own work inside the product.
So we didn't bet the whole product on it. We shipped to one set of companies first, watched the numbers, and rolled out to everyone only once the results held. Leading six designers alongside the PM and the founder, I spent as much of this project defending the model as drawing it.
- Remember a file was shared
- Guess which conversation10+ threads
- Scroll back through messageshundreds
- Search by exact filenameif you recall it
- Ask the sender to re-sendmost common workaround
- A second copy now existswhich one is latest?
Six steps, none of them the one people wanted. Retrieval depended on remembering a conversation — so the most reliable route to a file was asking a human to send it again.
re-upload, or give up
What the model committed us to.
- 01Design for the mental model, not the data model.
- 02One canonical object. Never a second copy to reconcile.
- 03Share by reference, so “latest version” stops being a question.
- 04Let people search the way they describe a file out loud.
- 05Permissions belong to the owner, per place the file lands.
Designing the rest around how people look.
With the model settled the direction was clear — but the two features that carried it, permissions and search, were the hardest things to get right, and the hardest to get built.
- Scroll the thread, or ask a teammate to re-send
- The same file uploaded two or three times
- Search that only matched the exact filename
- Open the workspace, filter, done
- One canonical file, shared by reference with a click
- Search across type, people, team, date and context
A personal workspace let people upload and organise without posting into a chat, then drop a file into any conversation by reference — killing most of the duplicate uploads.
Permissions were the fiddly heart of it: the same file could enter one chat read-only and another with download rights, owner-controlled per place it landed — so a shared document stopped changing under the people who depended on it.
And search took the most convincing. Instead of matching filenames, it combined the filters people actually think in — file type, who shared it, which team, when, and the conversation it came from. The vast multi-filter search people needed was real engineering cost, and I had to argue it wasn't a nice-to-have but the entire point of giving files a home.
01Filters in the words people useWhere, who and which team sit above the results as removable chips — the way people describe a file out loud, not the filename they've forgotten.
02The file stays pinned to its conversationShared by reference, the file pins to the top of the thread with its version and who last updated it — the chat keeps its context, and nobody posts a second copy.
03Access set where the file landsEach share carries its own access level, reshare rights and link expiry — so the same file can enter one chat editable and another read-only.
04Roles per person, owner in controlOwner, editors and viewers in one list, each role changeable in place — the owner decides who can touch a file, person by person.
Shipped to a few companies before all of them.
- Six designers, three squadsI led the design work and kept the dual model consistent across messaging, workspace and search.
- PM & founderWhere the storage and effort objections came from — and where the retention argument landed.
- Paying teamsInterviewed before, prototyped with during, measured after — a first cohort carried the release.
Three prototype rounds before build, then release to one set of companies and ninety days of watching the numbers. Only when engagement and retention both held did the workspace go to everyone.
What actually changed.
Giving files a home of their own changed how — and how often — teams used the product. Engagement as overall product activity, retention as company and user churn; both from Firebase, before vs. after.
The numbers tracked something simpler underneath: people stopped losing their own work.
What this taught me.
The instinct was to make message history smarter. The unlock was to stop treating files as a side effect of conversation and start treating them as first-class objects with their own home.
It taught me to design for the mental model, not the data model. People had told us, plainly, that they thought in files — the product just hadn't been listening. But the model was only ever the idea. Everything hard came after: carrying it past the people who had to pay for it and build it, and proving with real numbers that the bet was worth making.
Engagement and retention come from Firebase, measured before vs. after the file workspace shipped — engagement as overall product activity, retention as company and user churn and the share of people who moved into the workspace and stayed. Happy to go deeper in conversation.