The secret to HashiCorp's "overnight" DevOps success

HashiCorp has cracked the code on what it takes to build great DevOps tooling. It's easier than it looks.

Devops for software continuous operations and development or programming concept, multi color arrows pointing to the word Devops at the center of black cement chalkboard wall

Image: Getty Images/iStockphoto

Among DevOps toolchains, HashiCorp builds some of the most popular tools. Among developers, tools like HashiCorp's Vagrant, Consul, Terraform, Packer, and more are considered household names. Interestingly, while they have become the go-to DevOps tools for a generation of developers, they didn't seem obvious at their inception. As HashiCorp co-founders Mitchell Hashimoto and Armon Dadgar tell it, their early products felt right to them even if their initial reception in the market resembled a "flatline." 

If this seems a little Steve Jobs-esque, that's because it is.

SEE: Implementing DevOps: A guide for IT pros (free PDF) (TechRepublic)

Going with the (carefully considered) gut

In the early days of HashiCorp, the company almost had more products than employees. As the two founders of HashiCorp described in their Mostly Cloudy interview, there was an early emphasis on proving out their product vision before they started to hire. The problem was that external proof that they were on the right track was slow in coming, as Dadgar suggests:

[A] lot of people look at HashiCorp like, all the products were an overnight success, and I think it felt like the exact opposite for all of us. We had conversations at times with the board where they're like, "Should you just kill that project?"

And I think Terraform was probably like the longest burn. If you look at the download chart of (Terraform) for the first two years, it looks like a life support line, where it's just a flat line basically….[I]t's funny, because I think there was a lot of conviction on our part that's like, "This is the right technology, and the right approach (to) doing it." But (there was) not a lot of data that sort of backed that at all.

So I think part of it was just sort of convincing the board that markets are early. You still have to educate people. There's sort of a necessary product maturity before they can kind of get to that point. And I think almost all of our products … until they really got to their dot three, dot four releases did it see significant uptake.

Getting to the point where the HashiCorp founders felt like they were on the right track took considerable effort. As Hashimoto has said, "I write a lot of human language before I write computer language. I plan things out to a pretty detailed degree. For example before starting Terraform...Armon and I collectively wrote about 60 to 80 pages of Google Docs thinking through how it'd work before we wrote ANY code." Such planning doesn't guarantee success, of course, but it does help ensure that Hashimoto and Dadgar are seeing clearly. They might be wrong, but they won't be casually wrong. 

And, to be clear, sometimes they were wrong, as Hashimoto has outlined:

Our original commercial product we built ultimately fell hard for a lot of reasons, but one big one was we were trying to build something that individuals would like and large Global 2000 companies. That might be possible but it's really hard. When we decided to focus in on Global 2000 and "enterprise," we were much more successful. This mistake though ended up costing us years of engineering time.

Hashimoto and Dadgar aren't perfect in their evaluations of what the market needs, but their track record of getting most things right is impressive. 

SEE: Quick glossary: DevOps (TechRepublic Premium)

Taking time to get things right

The two founders created Terraform and Consul while students at the University of Washington, tasked with figuring out how to manage disparate infrastructure. Terraform seems like an overnight success, but it wasn't. At all.

As Hashimoto put it in the Mostly Cloudy interview:

The initial versions of Terraform were actually really bad. But the idea was solid in our opinion. But a lot of people also didn't understand the sort of "why?" behind it.

I'm of the opinion that things like that take time, and it's okay. And so now when we release something new, we get a lot of users right away. And it kind of freaks me out because I like the sort of slow burn; it gives you that time to mature.

This "taking time" has become harder as more venture capital has pushed into the developer toolspace. Arguably, however, it's doubly critical in the developer tooling space, given how important developers have become to enterprise differentiation. Slowing down to ensure the developer experience is right, as Atlassian, GitHub, and others have done before, is the key to overnight success...that takes years to deliver. 

Disclaimer: I work for AWS, but in my work I have no involvement (in any way, direct or indirect) with HashiCorp. This post was not written with reference to or in any way to help my employer, but simply to highlight the cool things HashiCorp is doing for developers (and ops).

Also see