Case study

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.

01 / Context

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
A shopper and a robot carry grocery bags home. Below, a floor plan shows the robot's route from the entrance through the living room to the kitchen refrigerator.

The expert configuring the system

Storage Engineer

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
02 / Problem

The project started as a technology migration

The starting assumption
“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

  1. 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.

    A storage engineer at her laptop with her hands on her head, thinking, “I hope I do not delete any data!”
  2. 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.

    A storage engineer at her laptop imagining the old system as a pyramid of Grade, Pool, Rules and Policy, while her screen shows it upside down, the order in which the old experience made her work.
  3. 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.

    A girl carefully adds two more cards to a small house of cards on a table, thinking, how do I add 2 more?
  4. 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.

    A blindfolded girl holds out her hands with a question mark in her thought cloud.

What looked like a usability problem had become an operational problem.

The project was no longer about migrating pages

We started with

Angularize the existing automated data-management experience.

Research reframed the problem as

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.

03 / Strategy

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.

  1. 01Reduce concepts

    Users should not have to understand internal StorageGRID implementation objects simply to express where data belongs.

  2. 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.

  3. 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.

04 / Solution

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:

  1. Policy
  2. Rule
  3. Storage pool

rather than:

  1. Policy
  2. Rule
  3. Erasure Coding profile
  4. Storage pool
  5. 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.

Existing concepts versus new simplified concepts. Before, a policy contained rules, which contained EC profiles, storage pools and storage grades. After, a policy contains rules, and each rule points directly to a storage pool. The EC profile and storage grade concepts are removed.

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.

The existing retention diagram, with its issues called out, next to the proposed retention diagram. The proposed version labels each placement by time period and storage type, using icons and text rather than color alone.

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
  1. Storage grade
  2. Storage pool
  3. EC profile
  4. Rule
  5. Policy
After
  1. Policy
  2. Rule
  3. Storage pool
The redesigned configuration flow as five connected screens: create policy, select rules, create rules, select the created rule, and policy created. The first and last steps form the policy flow, and the middle three form the rule flow.

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.

Early exploration of the tag model: diagrams showing how a tag on buckets lets one policy rule target groups across tenants, and wireframes for the Bucket tags list, the Create bucket tag dialog, and the list with tenants, traffic classification policies and ILM rules.

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.

  1. Define intent
  2. Configure policy
  3. Observe outcome
The StorageGRID Grid Manager ILM dashboard on a laptop, showing the ILM queue and ILM evaluation rate charts, plus ILM information such as the scan period forecast and the average scan period per object.

Glimpses of the improved workflows

Four screens from the redesigned StorageGRID Grid Manager, layered together: the ILM rules list, the Create ILM rule form, the ILM policies list, and the Create a policy page.
05 / Results

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.

Policy complexity

Maximum rules in one policy

BeforeAfter

98.3% reduction

Customers could express the same policy intent with dramatically fewer rules.

Incorrect placement

Rules associated with incorrect placements across customers

BeforeAfter

92.9% reduction

Simpler configuration substantially reduced rules associated with incorrect data placement.

Support cases

Related support cases

BeforeAfter

93.7% reduction

Fewer configuration problems translated into significantly fewer customer support incidents.

Support cost

Related support cost

BeforeAfter

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.

Benchmark score185
The benchmark scoring method: a criteria grid scoring each sub step from 1 (understood and complete) to 4 (unclear and incomplete), individual scores per sub step, and the cumulative score of 5, down from 18.

Cumulative benchmark complexity score for the policy-configuration workflow, measured with the same benchmark before and after the redesign.

06 / Reflection

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.

Future directions, not part of the original project

Where I would take the system next

  1. 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.

  2. 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.

  3. 03Close the observability loop

    Connect policy configuration more directly to actual placement performance, so engineers can see where policy intent and system behavior diverge.