Note: The work I am discussing on this page was created during my time at Northrop Grumman. Due to the sensitive nature of working on DoD-oriented software, this summary will only include generalized metaphors and a write-up of the work, with a similar prototype (not the same designs themselves), created via Figma. Here is a link to the similar prototype.
Context: In January of 2015, I joined a UX project team for my first large project at Northrop. The goal was to update a piece of software that warfighters used to control a radar. The software was so unusable that the soldiers claimed it was a paperweight.
Skills Used: 
Challenges:
- Personally, this project was my first time dipping my toe into the acronym-laden world of missile defense-focused projects, so there was absolutely a learning curve, especially with the project’s history.
- We had limited access to users. We were lucky enough to have a series of trips to bases, but during the time between those trips, we were really shooting in the dark with designs. One option we had was to work closely with Subject Matter Experts (SMEs) at times when we could not readily get access to warfighters
- The software engineers we worked with had a completely different mental model of how things should be built, although we provided thorough design documentation.
Contributions:
- User research support, including:
- Writing and moderating expectancy tests
- Administering the System Usability Scale tool to participants
- Analyzing qualitative and quantitative research data
- Interaction design support, including:
- Timeline – a feature meant to help users review historical data
- Compass icon design
- Image search tool
- A measurement tool for points of interest on a map
- Information architecture support, including:
- Conducting a content inventory on how the existing software was structured
- Card sorting based upon labels pulled from the requirements
Narrative: I joined this project in January 2015, after some of the initial research and interface redesign had started. We were picking back up on an effort that had started the previous summer.
We were lucky enough to have our first user research event in late January, and I was asked to assist with several things:
- Helping design some features that we could use for testing in this upcoming event
- Helping to write research questions and tasks for our users to complete during this event
- Assisting with conducting these user tests and research interviews
- Information architecture research in the form of a card sorting exercise
At first, we didn’t have a digital prototype to test this system with, only paper wireframes.
One of the big findings was that we’d need a tool for the users to see historical data that had previously been captured. This gradually evolved into a tool that we came to call the timeline. I was the primary designer for this feature, taking visual style cues from the more senior designer on the project.
My timeline designs went through numerous iterations. We discovered that certain imagery we thought ought to be included on the timeline could actually be tucked away elsewhere in a searchable image gallery. I also served as the primary designer for the image gallery tool.
Along the way, we met with the software team consistently about the feasibility of our designs. They eventually had a software prototype for us to take to users and run usability tests. I learned a lot about what level of detail might be required for design implementation, as the software that they built did not always match our specifications. It was helpful to have a dialogue with the developers about what they needed from us.
I eventually assisted with four separate user events over the course of the project, in addition to all of the design work, and served as both a researcher and a designer throughout. We delivered our final batch of designs and research recommendations to the software team.
Sadly, we never got to hear exactly when it was fielded, but I learned an immense amount from being on the project.