Design is an integral part of the way we build software at Puppet Labs. More specifically, we strive to answer a very simple question: what does the user need? This isn’t always an easy question to answer, but we’ve been happy with our success in doing so. User empathy is our conduit for user satisfaction.
In real-life terms, what does design at Puppet look like? Let me show you a project that just finished its initial design phase: Puppet Sites.
What do users need?
Puppet admins want to spend their time managing nodes that are under Puppet control. They don’t want to spend their time adding nodes to their deployments. On the contrary, their goal is to start managing new nodes as quickly as possible. We formalize this need in the following way:
As a Puppet admin I want to easily add new nodes to my deployment so that I can start managing them as quickly as possible.
How do we we satisfy user needs?
The current workflow for adding nodes to a deployment is as follows:
- Configure puppet.conf with the location of the master/CA
- Perform an agent run on the node
- Login to the CA
- Sign the node’s certificate
- Perform another agent run on the node
The problem with the existing workflow is that it appears to have nothing to do with adding new nodes to a deployment and everything to do with signing certificates. There’s a disconnect between the workflow and the user need.
To fix this, we did three things:
- We introduced the concept of a site. A site is a service that owns the list of nodes in your deployment, the authentication mechanism for adding new nodes to your deployment, and the configuration of Puppet services in your deployment.
- We changed the semantics of the workflow, so that it directly addresses the user need.
- We eliminated the overhead of signing into the CA and manually signing node certificates. There are secure ways to do this that don’t involve user interaction over SSH.
The workflow now resembles the following:
- Login to the site host
- Generate a pre-shared key
- Join a node to the site using the pre-shared key
- Repeat step 3 for every node you want to add to the site
We now have a workflow to fulfill the user’s goal. But notice that we’re still not talking about sites in technical terms. This workflow could apply equally well to a Puppet Face, a REST API, or a Dashboard plugin.
How do users interact with our workflows?
It’s all well and good to produce a general workflow for addressing a user need, but eventually you have to tie it to a real user interface. For the initial release of Puppet Sites, we decided to focus on two user interfaces: a Puppet Face and a REST API.
A designer is nothing without regular interaction with customers. While designing user interaction, we stayed engaged with our internal operations and professional services teams. After several rounds of feedback, the design of the Puppet Face for the workflow given above resembles the following:
node02$ ssh firstname.lastname@example.org Last login: Mon May 7 18:15:43 2012 site02$ mount /media/usbdisk site02$ puppet site generate key > /media/usbdisk/site.key site02$ umount /media/usbdisk site02$ exit node02$ mount /media/usbdisk node02$ puppet node join site02.domain.com < /media/usbdisk/site.key Trying to add node02.domain.com to the site at site02.domain.com... Use `puppet site status node02.domain.com` to confirm success To stop waiting for the command to complete, press Ctrl-C. The command will still complete in the background. Added node02.domain.com to the site at site02.domain.com
What do users think?
We strive to make our design process as agile as our engineering process. We specifically avoid a waterfall model, where the design is completed in an ivory tower, then handed over the wall for implementation. Instead, our designers sanity check their design with internal and external users, talk to architects and engineers to make sure they aren’t violating the laws of physics, and stay involved in the project until it ships, making course corrections as necessary.
The Puppet Sites project is still underway, but we’ve already discovered mistakes made early in the process, and corrected them. Each group of users has been vital to this iterative process.
Our internal users made us aware that omitting a pre-shared key system was a poor idea. By themselves, the two other fixes—changing semantics and introducing sites—weren’t sufficient to solve the user goal of “quickly” adding nodes to their deployments.
Our architects made us aware of a “law of physics” deal-breaker in the design, where users could have passed their pre-shared key as a flag to puppet node join. This would have exposed the key to sniffer processes on the host machine, and represented an unacceptable security risk.
Our external users helped us realize that the concept of a “site” is foggy at best and they didn’t really understand the problem it was designed to solve. Also, they were concerned that we were deprecating existing functionality without providing a drop-in replacement. We’ve been working to ameliorate these concerns by formulating clearer stories around the problems that sites solve.
Design at Puppet Labs
Of course, Puppet Sites does far more than just provide admins with an easy way to add new nodes to their deployments. For the sake of brevity, I’ve only highlighted this one user story. However, having a site also helps Puppet admins who want to…
- …get a list of all the nodes in their deployment with a single command, so they don’t have to trawl multiple services to get this information.
- …centrally manage the configuration of all nodes in their deployments, so they don’t have to manually manage puppet.conf on each node.
- …access information about Puppet services from their manifests, so they don’t have to hardcode the location of their services into their manifests.
You can expect Puppet Sites to be available soon, as a point release for Puppet 3.0.
In summary, the UX team at Puppet produces three main artifacts: user stories, workflows, and wireframes.
- User stories allow us to talk about the needs of our users in a non-technical, goal-oriented way.
- Workflows describe the tasks users go through to achieve their goals.
- Wireframes are mockups of the actual systems that users use to complete these tasks.
Not all of our projects follow this process exactly, but, in general, the above holds true. User story to workflow to wireframe. Rinse and repeat as necessary. That’s how we do design at Puppet Labs.