Simplifying Data Management at Scale
Redesigning StorageGRID policy configuration around the storage engineer’s mental model
StorageGRID automatically determines where enterprise data is stored, how it is protected, and how long it is retained.
I was initially asked to modernize its Information Lifecycle Management experience as part of a frontend migration. Research revealed a much larger problem: customers were managing highly complex policies through a configuration model that did not match how storage engineers thought about their data.
I led the redesign of the policy model and workflow to make configuration easier to understand, safer to change, and substantially easier to operate at scale.
- Company
- NetApp
- Role
- Lead Designer
- Team
- 2 PMs · 6 Developers · 2 QAs
- Impact
98% fewer rules in complex policies
93% fewer placement-related configuration errors
94% lower support cost
Watch the quick overview
A plain-language walk through the project: why engineers hesitated, what we changed, and what I would do differently with today's AI.
Think of automated data management like giving a robot instructions for putting away groceries
Imagine a robot putting away everything you bring home. For every item, it needs to know:
- What is it?
- Milk
- Where should it go?
- Kitchen refrigerator
- How should it be stored?
- Refrigerated
- For how long?
- One week
Enterprise data management works similarly. A storage engineer defines rules that tell StorageGRID what data is affected, where it belongs, how it should be protected, and how long it should remain there. Multiple rules together become a data-management policy.
- Shopping item
- Data to be stored
- Robot’s rule
- Data-management rule
- Sequence of rules
- Data-management policy
- Robot
- Data-management engine

The expert configuring the system
Storage engineers plan storage infrastructure, monitor system health and capacity, handle complex storage-related incidents, and evaluate infrastructure choices.
For lifecycle management, their challenge is more specific: create policies that safely place enormous volumes of data without accidentally moving, deleting, or under-protecting it.
- Plans
- Storage infrastructure · Capacity · Performance
- Operates
- Monitoring · Upgrades · System health
- Troubleshoots
- Complex storage incidents · Placement problems
- Configures
- Lifecycle policies · Storage rules · Data protection
The project started as a technology migration
“Angularize all the automated data management pages.”
The initial request was implementation-driven. The existing Information Lifecycle Management experience had been built on an older frontend framework and needed to migrate to the current platform.
A straightforward response would have been to reproduce the existing workflows in the new framework. Instead, I used the migration as an opportunity to ask:
Should we carry the existing experience forward at all?
Before redesigning the interface, I looked at how the system was failing
I combined four forms of evidence.
- Usability testing
- How engineers understood and configured policies.
- Surveys
- How confident they felt using the system.
- Heuristic + competitive analysis
- Where the configuration model introduced unnecessary complexity.
- Behavioral + support data
- What customers were actually configuring, and where those configurations were failing.
The qualitative research explained why people struggled. The behavioral data showed the scale of the consequence.
Four things made policy changes feel risky
Users did not feel safe making changes
They could not predict what a policy change would do.
- 213
- rules tied to incorrect placements
A tool is hard to use when you cannot predict the consequence.

Use the ← → keys, click an edge, or scroll sideways.
Users did not feel safe making changes
They could not predict what a policy change would do.
Before the redesign- 213
- rules tied to incorrect placements
A tool is hard to use when you cannot predict the consequence.

The model reversed the user’s mental model
Engineers start from the policy they need, not from storage concepts.
Before the redesign- 18
- workflow benchmark score
The system made users think like the product.

Scaling meant changing policies again and again
Every change added another rule to an already delicate structure.
Before the redesign- 249
- rules in one customer policy
Growing should not mean rewriting policies.

Users could not see the current state of the system
Policies were changed without knowing the effect.
Before the redesign- 418
- related support cases
- ~$0.5M
- related support cost
You cannot change safely what you cannot see.

What looked like a usability problem had become an operational problem.
The project was no longer about migrating pages
Angularize the existing automated data-management experience.
How might we simplify the setup of these intricate policies so storage engineers can manage data efficiently?
Instead of preserving the existing configuration model in a new frontend framework, we redesigned the model itself.
Simplify the system before simplifying the screens
Research suggested that improving individual pages would not be enough. The underlying configuration model needed to change. Three principles guided the redesign.
- 01Reduce concepts
Users should not have to understand internal StorageGRID implementation objects simply to express where data belongs.
- 02Match the user’s mental model
Start from the outcome the engineer wants, then translate that intent into system configuration, not the other way around.
- 03Make consequences visible
Help engineers understand both what a policy will do and what the system is currently doing before they commit to a configuration.
Remove concepts users should not have to manage
The first solution was not visual polish. It was reducing the conceptual model. The existing configuration required users to understand multiple internal constructs before they could create a policy.
The redesign absorbed or removed unnecessary intermediate concepts so engineers could focus on:
- Policy
- Rule
- Storage pool
rather than:
- Policy
- Rule
- Erasure Coding profile
- Storage pool
- Storage grade
The goal was to reduce both the learning curve and the opportunity for misconfiguration.
The simplest interface is sometimes the one with fewer things to understand.

Make lifecycle behavior visible
Lifecycle rules are temporal. Data may need one kind of protection when it is created, another after several days, and a different destination later. The previous experience expressed these rules primarily as configuration fields.
I introduced visual timelines so engineers could inspect:
- when placement changes occur
- how long each state lasts
- where rules overlap
- whether the resulting lifecycle matches their intent
Configuration became something users could inspect, not just something they had to remember.

Invert the workflow to match how engineers think
The previous product started with infrastructure concepts and worked upward toward intent. Users thought in the opposite direction. They started with the desired policy, then determined the rules and placement required to achieve it. I reorganized the workflow around that mental model.
- Before
- Storage grade
- Storage pool
- EC profile
- Rule
- Policy
- After
- Policy
- Rule
- Storage pool

We stopped teaching users how the system was built and started designing around what they were trying to accomplish.
Separate policy intent from infrastructure
Policies were frequently changed because rules were tightly coupled to individual infrastructure objects. That created ongoing administrative work as systems grew and storage configurations changed.
I explored using tags to introduce a layer of indirection between policy intent and specific infrastructure. Instead of repeatedly rewriting policies, engineers could target meaningful groups while allowing the underlying infrastructure to evolve independently.
The goal was not simply to add tags. It was to make policy intent more resilient to infrastructure change.

Show users what the system is doing now
Policy configuration should not end after clicking Save. Storage engineers also need to know whether the system is behaving as expected. The redesigned experience surfaced operational state such as:
- time required to place an object
- objects still waiting for placement
- estimated time to complete placement
This connected configuration with its real-world consequence.
- Define intent
- Configure policy
- Observe outcome

Glimpses of the improved workflows

Simplifying the configuration model changed the behavior of the system
The impact was visible not only in usability, but in the complexity of the policies customers created, the number of incorrect placements, and the resulting support burden.
Maximum rules in one policy
98.3% reduction
Customers could express the same policy intent with dramatically fewer rules.
Rules associated with incorrect placements across customers
92.9% reduction
Simpler configuration substantially reduced rules associated with incorrect data placement.
Related support cases
93.7% reduction
Fewer configuration problems translated into significantly fewer customer support incidents.
Related support cost
93.6% reduction
Reducing configuration complexity materially lowered the operational cost of supporting the feature.
The workflow became structurally simpler too
I used the same benchmark before and after the redesign to evaluate the complexity of completing the policy-configuration workflow. This provided another measure of simplification beyond subjective usability feedback.
The redesign did not merely feel simpler. The workflow contained materially less complexity.

Cumulative benchmark complexity score for the policy-configuration workflow, measured with the same benchmark before and after the redesign.
The migration was the trigger. Simplification was the product opportunity.
The original request could have resulted in a faithful reproduction of the existing experience on a newer frontend stack. Instead, research showed that the configuration model itself was creating uncertainty, placement errors, and significant support burden.
By simplifying the domain model, aligning the workflow with the storage engineer’s mental model, and making system behavior easier to inspect, the redesign reduced both cognitive and operational complexity.
Modernizing the technology mattered.
Modernizing the mental model mattered more.
Where I would take the system next
- 01Intent-driven policy creation
Explore guided or natural-language configuration for engineers who understand the outcome they want but do not want to manually construct every underlying rule.
- 02Simulate before activation
Let engineers ask, “If I activate this policy, where will existing and future data be placed?” before the policy takes effect. This would further reduce uncertainty around consequential configuration changes.
- 03Close the observability loop
Connect policy configuration more directly to actual placement performance, so engineers can see where policy intent and system behavior diverge.