Team
Cameron Lancaster - Principal Product Designer
Marwan Sulaiman - Lead Software Developer
My Role
UX + UI Design
UX Research and Strategy
Deliverables
A complete SaaS product, preparing for beta launch in Q2 of 2021
Timeline
January 2020 - Present
The Challenge
When writing code in Go, software developers do not have any good solutions when it comes to managing dependencies.
The common workaround of “vendoring” dependencies disrupts the developer’s workflow and creates security flaws for their organizations.
Our Solution
GoFig is a dependency manager for Go developers that can be implemented into their workflow in only a few minutes.
It erases the faulty “vendoring” practice from the developers workflow and manages dependencies securely and efficiently.
Simplified User Flow
Project Brief
GoFig is a package management platform for the Go programming language that allows a streamlined and secure workflow for software developers. The platform as a service product is built around an open source project that was started by a group of software engineers from Microsoft (www.github.com/gomods/athens).
In January of 2020, I was hired to lead research and design of a high-fidelity prototype that would serve as the basis for GoFig’s launch interface. In this case study we will review how UX and product design tools were used to uncover the core of what users and stakeholders needed in an MVP.
A dependency manager is a platform that is used by software developers to store and manage dependencies. Dependencies may be likened to plugins that operate within larger pieces of code. With a dependency manager, these lines of code are stored and automatically updated via a CI/CD platform throughout the larger bodies of codes where they are referenced in. Most major program languages function through larger open source dependency managers, such as NPM for Javascript.
Until recently, Go did not have a protocol that allowed for developers to implement their own dependency manager so that Go and the CI/CD platform can talk to it. With the new protocol recently being implemented, our objective was to identify the major pain points for programmers in their current workflow and design an experience that would allow for programmers to efficiently implement GoFig as the primary enterprise dependency manager for their organizations.
Research Process
In order to design the platform appropriately, we began by researching our user base: software developers who use the Go programming language.
Our primary research tool was interviews, which were conducted as open ended conversations that allowed us to understand the issues and empathize with a Go programmer’s workflow.
Prospective interviewees were identified on Github as Go programmers before we reached out for an interview.
You may view our sample interview guide here.
Through affinity diagrams, we were then able to recognize how Go programmers currently deal with these issues and highlight how GoFig could help developers through a dependency management platform for enterprise.
Takeaways
Our research helped inform us about the pain points our users experience as programmers and identify opportunities for our product.
Most importantly, we identified:
Our users current workflow
Why current solutions aren’t working for our users
Critical information necessary for implementing the product easily
Persona Introduction
After sorting our insights into recognizable patterns, I created a persona to help develop a thoughtful representation of the user that we were designing for. The diagram below outlines this persona with our user’s motivations, pain points, and tools used throughout the software development process.
Journey Map
The next part of my process was to create a journey map through which we could visualize when these pain points occur for our potential users.
Insights Overview
Insight #1
Users want to introduce tools that simplify their workflow, rather than complicate it.
Current dependency management solutions break the workflow of Go developers, and so they find it easier to manage dependencies manually
A new dependency management solution needs to be easy to introduce into the user’s workflow
Insight #2
Go programmers currently manage dependencies through “vendoring”.
Programmers manually push their dependencies to GitHub
Other programmers who want to use those dependencies must manually copy the dependencies into the code that they are writing, rather than having a platform manage it for them
GitHub has informally become the dependency manager for Go
Every change feels massive
Insight #3
Vendoring creates security flaws for organizations.
There are duplicate copies of dependencies throughout the teams of programmers that rely on them, creating a large margin of error for these dependencies to differentiate between one another as updates are made
Large amounts of time must now be spent for teams to communicate these changes and make sure that they are implemented across and organization
Our Solution
With GoFig, organizations can streamline their workflow and ensure that security measures are implemented in an appropriate fashion.
Product can easily be implemented to the users workflow
Erases “vendoring” from the users workflow and all of the problems that come with it.
Product Flow + Site Map
After researching and gaining insights on our users, our first step was to create a flow through which our users would experience the product. This also gave me a clear vision of what pages needed to be designed.
Through design workshops, we iterated on multiple low fidelity versions of our site map, ultimately converging our research and testing into a viable direction for the product. This version includes all of our main pages, some of the information the user may expect to see on those pages, and demonstrates the user’s flow while they are engaged with the product.
Sketching, Wireframes, & Visual Design
The next step of our process was to brainstorm and sketch what some of these pages would look like. Although many of the pages were simple, it was important for us to visualize the different components on the page and make sure that we had thought about everything appropriately.
Low fidelity prototypes allowed us to outline a digital format for the product and further iterate on the information architecture before moving our focus to visual and interaction design.
Launch + Next Steps
In conclusion, we found that software engineers didn’t want more programs and tooling, they wanted less. And so at its core, the experience didn’t need to be seamless with their workflow, it needed to be invisible.
Our solution was to design a 3-step process: sign up, deploy, implement. In only a few minutes, software engineers will now be able to run our product and then never think about it again.
GoFig is now being developed and tested internally before launching for beta testing in Q3 of 2021. Our aim will then be to seek user’s feedback on their experience and use design and usage metrics to formalize our pricing strategy. GoFig will be available to software engineers around the world by Q4 of 2021.
In the meantime, you can view some of our designs below. If you have any questions or feedback on this case study, please feel free to reach out. Thanks for reading!
