Google

Finding the right data access

Helping people find the right access role for the data they need, including one filter we shipped, tested and replaced within about a month.

Problem
People across Google needed access to sensitive internal data to do their jobs, and getting it meant finding the right role among thousands. Search did not match how people think about data, and some teams had built their own workarounds.
My role
Lead product designer for the platform, working with two UX researchers, a product manager and the engineering team.
Key decisions
  • Phased the filtering work, starting with data ownership and eligibility.
  • Shipped a first version of attribute filtering on a fixed date, then tested it against two alternatives the week after.
  • Adapted a pattern from another team instead of building a new component from scratch.
Outcomes
The tested design replaced the first version two weeks after the study, about a month from first launch, and its specs went to the shared component library for other teams to use.

Context

Lead Product Designer · 2023–2025

Services: Interaction design · UX research · A/B testing · Iterative design · Component design

This work was on an internal tool, so every screen on this page is a reconstruction with placeholder data. The patterns are real; the names, numbers and layout details are not.

data-access-tool / roles
HomeMy accessApprovalsRolesPolicies
Search roles, descriptions, or data sources

128 roles you can request

TeamEligible to requestData attributesClear filters
Regional sales reporting (read only)You have access

Summary sales tables for one region. No customer-level detail.

▼
Marketing spend by campaignPending approval

Campaign-level spend and budget data for planning analysts.

▼
Support ticket trendsEligible

Aggregated ticket volume and resolution times by product area.

▼
Role search with team and eligibility filters. Reconstructed with placeholder data.

The problem

The platform decides who can see sensitive internal data. As more teams adopted it, the number of access roles grew quickly, and finding the right one turned into a needle-in-a-haystack search.

Research with our UX researchers kept surfacing the same issues. People searched for the name of the table they needed rather than a role. They couldn't tell which roles would give them that data, or whether they qualified for them. Role names and descriptions were often unclear, and the main filter assumed knowledge of how data ownership was organized that most people didn't have.

A phased approach to filtering

I took the early concepts into feedback sessions with users and refined the flows from what we heard. That led to a phased plan built around filters people could understand.

  • Phase one added filtering by data ownership and by eligibility, so people could hide roles they couldn't request.
  • Phase two added search by policy notes and by data attributes, things like region or cost center that match how people already describe the data they need.

Alongside search, I designed an approval flow that shows requesters and approvers what a change to a role or policy would affect before they act, a status for roles that were still being created or removed, and search for broad-access roles that are granted automatically. Later work let teams register their own APIs, create access policies for them, and filter by permission.

Showing what a change will do

Before someone changes a role or policy, impact analysis shows them and their approvers who will gain or lose access. I designed it alongside the approval workflow.

  • Counts and lists that disagreed: during QA we found the number of affected people could disagree with the list beneath it, such as a large count with a short list or none. That looked like a bug to the person reading it. As a first step, my engineering partner and I decided to show only the count, with a message saying the list couldn't be returned but the count was accurate.
  • Large changes: with our product manager, we settled on showing the count on the page, listing names only for small changes, and offering an export for everything else. If an export ran slowly, people could carry on and get an email when it finished, so it wouldn't hold up their submission.
  • Net zero: when the same people are both removed and added, the impact is zero even though changes were made. The screen says so and explains why, so it doesn't look like an error.
  • Privacy: I raised the question of whether showing names next to the criteria behind a policy would reveal too much, and whether we should list people who could potentially gain access at all.
data-access-tool / roles / review changes

Review the impact of this change

Regional sales reporting (read only)

248 people will gain access

Too many to list here.Export list

3 people will lose access

a.rivera@ · j.chen@ · s.okafor@

No change for 4 people

They were both removed and added, so their access stays the same.

This change will be sent to a senior approver.BackSubmit for approval
Impact analysis for a change to a role. Reconstructed with placeholder data.

Zooming in: the attribute filter

Attribute filtering was one of the filters users had been asking for consistently, because it matches how they think about the data they need.

Why it was hard

The other filters were flat lists. Attributes work more like a schema. You pick an attribute category first, and that choice decides which values you can pick next, and those values are nested several levels deep. Nothing in our component set was built for that.

The first version worked around the gap by chaining existing components. Each category a user picked became its own chip in the filter bar, with its own nested dropdown to open, expand, check and apply. Building one useful filter meant working through several dialogs in a row, and people dropped off.

data-access-tool / roles
HomeMy accessApprovalsRolesPolicies
Search roles, descriptions, or data sources
RegionCost centerProduct line+ Add filter

Cost center

▸–Operations
✓Field operations
Logistics
▸Finance
CancelApply
Each category is its own chip with its own tree and its own Apply. Building one filter view meant opening, expanding, checking and applying several dialogs in turn.
The first version: one chip and one dropdown per attribute category. Reconstructed with placeholder data.

Shipping it anyway, with a plan

We knew the interaction model was wrong before launch. Users had been waiting for the capability, the release date was fixed, and building the right component first would have pushed the feature out by a quarter. I made the call to ship it and to have evidence in hand by the time we could fix it, rather than argue for a delay.

The people who use this tool are hard to recruit for research. They need data in the middle of some other task and don't volunteer for studies. So instead of standing up a new study, we added the attribute filter as a final module in a study our researchers were already running with experienced users of the tool.

Testing three directions

Another designer on the team and I explored eight directions in Figma and took three into the test:

  1. The launched version, one chip per category.
  2. A dedicated attribute bar below the main filters, where people built up selections in one place.
  3. A three-panel picker: categories with role counts on the left, the nested values for the chosen category in the middle, and every selection across categories on the right, with a single Apply.

The three-panel picker started as a pattern another team in a different part of the company had built for a similar nested selection problem. My engineering partner and I met with its designer to understand what it was built for and where it would break, then adapted it.

The test was blind. Each group completed the same filtering tasks on one version without knowing which one was live, and the researchers compared task completion and how favorably people rated the experience.

data-access-tool / roles
Filter by data attributes

Attribute

Region42 roles
Cost center118 roles
Product line67 roles
Business unit31 roles
Search cost centers
Select all
▾–Operations
✓Field operations
✓Logistics
Facilities
▸Finance
▸Marketing

Your selections

Region: North America×
Cost center: Field operations×
Cost center: Logistics×
CancelApply
The three-panel picker that replaced it. Reconstructed with placeholder data.

Outcomes

Participants preferred the three-panel picker on both measures, and their reason was consistent: they could browse categories, drill into values, select across categories and review everything without leaving the component. The first version asked them to hold the whole filter in their heads across several dialogs.

  • While the results were being analyzed, my engineering partner built the picker in our codebase, so it was already working when I presented the recommendation.
  • It replaced the first version in the next release, two weeks after the test.
  • Role counts on each category show how much a selection will narrow the results before you commit to it.
  • Reusing a pattern from elsewhere in the company meant the fix shipped on the normal release schedule instead of waiting a quarter, and it gave people a selection pattern they had already seen in other internal tools.
  • The component and its specs went to the shared design system and component library so other teams could use it.

I didn't capture usage or support metrics for the filter after launch, so the study results are the evidence for this change. The picker has since become the default for nested selections in the product, and the next phase of search work builds on it.

What came next: proposing policies with AI

Search fixed half the problem. The other half was creation: every role on the platform needs seven parameters, and writing them correctly took specialist knowledge most requesters didn't have.

In 2025 I started design discovery for an AI-assisted flow that turns a plain-language request — "my team needs read access to the sales tables in this region" — into a proposed policy. Working from engineering's early model work, we found that three or four of the seven parameters could be filled automatically. The rest had to be generated as suggestions a person would confirm.

That split shaped the design questions. Which steps should the system just do, and which should it propose and explain? Where does the entry point live: inside the existing flow, on the homepage, or as its own assisted journey? And how does a person's correction feed back into the next suggestion? I partnered with a UX researcher on a research plan to answer those before we committed to a design.

Concept. Reconstructed with placeholder data.
Concept. Reconstructed with placeholder data.
Concept. Reconstructed with placeholder data.
Concept. Reconstructed with placeholder data.
Concept. Reconstructed with placeholder data.

When I left, the flow was mocked up and specced. I'm no longer at the company, so I'm not privy to product decisions about internal tools.

The most useful thing the discovery did was draw a line before anyone designed screens: which of the seven parameters the system could fill from data it already had, and which it could only guess at. The rest of the design followed from that line. Filled fields could stay quiet. Suggested ones needed a visible label, a way to correct them, and a review step where the approver could see what had been suggested and what a person had changed.