Have you ever downloaded software and just can’t believe how bad it is? Have you ever struggled to accomplish one simple task on a system and get frustrated due to its poorness in all aspects? Chances are, the developers who built the system did not, in fact, eat their own dog food.  

Dog food? Is that a typo or do you really mean we have to eat the thing we feed our pets? Of course, it is not a typo, and not an ad for pet food either. To eat your own dog food is a regularly used phrase within tech companies that refers to the practice of using their own products. As one of the developers in CMC Global has said “One of my best pride to say when working here is that I am not only eating but devouring my own dog food every day”.

Eating your own dog food

Eating your own dog food/ dogfooding is the slang that means using your own software products internally. This is not only a way of product testing, but also a way of ensuring its quality for any potential customers in real-world usage. Generally, dogfooding demonstrates confidence in the developers’ own products.

We must acknowledge that product development is a pole apart from being the end users who must operate it every day. Coding and consuming are very different. The implications of “dog food” and not something normal or tastier say it all “it lessens the appeal of your product and yet, you still have to eat it yourself”. Only by that can you demonstrate to audiences that it is a good product despite any contrary perceptions they might have.

By putting yourself in the end-users shoes, you have the chance to actually close the gap between you and your users, understand your product more and make adjustments to it if necessary. 

There are two main areas in which you might be eating your own dog food. 

• When you use your software within your everyday operations, in much the same way that a customer would. 
• When you use your software in a testing capacity, iron out any performance or usability kinks before releasing it to customers.

Origins of “eating your own dog food”

The editor of IEEE Software mentioned a 1970s television ad for Alpo Dog Food, Lorne Greene, saying that he fed his dog Alpo. Another reason for this term may be the board chairman Kal Kan Pet Food, who was told to have eaten a genuine can of dog food during a shareholders meeting (this myth is not to be testified till this day).

But it is not until it is first coined by Microsoft manager Paul Maritz in 1988 in an email with the subject line, “Eating our own Dogfood”, did the terms become stuck. In the email, Maritz challenged a colleague to increase internal usage of the company’s product.

Today, other less grotesque iterations such as “ice-creaming”, or “drink your own champagne” have become quite familiar to the people, but somehow can not replace the original buzzword.

Taste the benefits

Dogfooding is important, but what specifically does your company get out of it? The benefits of eating your own dog food spread surprisingly far throughout your business.

Product Confidence

First and foremost, eating your own dog food adds authenticity to your marketing efforts. When corporates use their own software, they are demonstrating to their customers whether they are old, existing, or potential ones that the company has huge confidence in their products.

Another plus for this is that it saves the potential damage control and even embarrassment if your product needs to be improved, or when customers see you are using a competitor’s product. If you have to use your competitor’s product, how good must it be? How bad must yours be? Isn’t your product supposed to be superior?

Can your marketing department answer these questions? There is no way to do such a thing.

In other words, dogfooding puts your money where your mouth is.

Identify with customers

Putting yourself in your customer’s shoes, you will have the chance to get first-hand experience of the way your customers view your product. You will clearly see their demand and directly evaluate whether your solution solves their pain points, and to what extent.

Using your own product enables any developers to discover all the annoying little usability issues that your customers will have to deal with every day. Don’t let a bug become a feature, that’s what they say. So, dogfooding means you can identify with your customers better: making for better, more empathetic customer service.

Find bugs

Another plus is that you get to quickly find the bugs that are most likely to affect your customers. According to Murphy’s Law (the theory that states that if toast can land butter-side down, it will do; typically known as “Anything that can go wrong will go wrong”)  real end users will typically find bugs that weren’t uncovered in the standard testing process.

Eating your own dog food, then, gives you an extra way to find bugs in your software and improve the quality of your product.

Encourage cooperation

Development is often detached from the front-facing service and support teams. While programmers have their heads in the code, they don’t have to deal with the end user like their PR or Custom service colleagues do.

That problem can be fixed with dogfooding, as coders become the end user. This can also lead to stronger cooperation between different teams in an organization. When everyone is experiencing the product as a user, it is easier to get on the same page.

What if the dog’s dinner is bad?

After all, eating your own dog food is not always enjoyable.

Obviously? You might not be the one the product was built for!

We have talked about putting ourselves in others’ shoes, but what if your product aims at one particular sector or skill set? Now that your team of developers doesn’t actually have logistic knowledge and the need to use one, what is the point?

For example, you are a tiny startup building a product for a Fortune 500 megacorporation, or a team of millennials with tech products aiming at improving the lives of retirees. So, when you evaluate internal feedback to the product, ask yourselves: “Is this the same feedback a mobile frontline worker would give?  It would be dangerous for the product to become something that fits our own needs perfectly but neglects the true target audience.

It tastes bad

Dog food, unsurprisingly, doesn’t taste good. When eating your own dog food as part of your testing process, your own ideas on what quality is acceptable can taint the view of the product. You might be making it taste worse than it is.

Members of the company are arguably too close to the product to recognize where its value lies particularly if you had a different vision for the end product.

Conclusion? Keep eating!

At the end of the day, what can we do about these shortcomings? One of the best solutions is to make your whole company, the developers, but also your marketing team, your customer support wizards, your HR department, etc. eat the food with you. 

By operating your software on a company scale, you really put your software to the test. This way enables you to expand the knowledge base, experience and variety of user needs so that you can adjust the final product to be more representative of your users. Moreover, the wider the range of people in your company using your product, the more you reduce the likelihood of biased views. 

Eating your own dog food helps you make sure you’ve not made a dog’s dinner of your software product. From practicing what you preach to putting yourself in the customers’ shoes, eating your own dog food instills trust and confidence. To boot, dogfooding improves your service and software and encourages teamwork across your organization.

So, isn’t it about time you tucked into a plate of your own dog food?