What is Dogfooding in Tech? Explained

As a techie, you might come across the term dogfooding while working with testing software. In this article, we’ve covered dogfooding. It explains how it fits within the quality assurance (QA) procedures, its best practices, and common misconceptions surrounding it.

Dogfooding refers to the practice of using one’s own products or services internally before releasing them to the public. It’s also known as “internal beta testing”. While dogfooding, businesses get employees to use the new products they’re making and learn more about their strengths and weaknesses before public rollout.

Companies like Apple, Google, and Microsoft have been dogfooding since the early days of tech. They aim to establish a product culture where employees from all over the business have exclusive access to new products. This is typically done through Early Access Programs (EAPs). The ultimate goal is to push employees to adopt the technology they’re innovating and collaborate on ideas on what works, what doesn’t, and what needs to be improved.

Also Read: What is Beta Testing?

Interestingly, the true origin of the term "dogfooding" isn’t confirmed. However, there are a few popular origin stories about its first usage.

• The term is thought to have been inspired by a 1970s commercial for Alpo dog food. In it, actor Lorne Greene encouraged viewers to feed their dogs Alpo, claiming he fed it to his own dogs.
• In the tech industry, dogfooding is believed to have been popularized in 1988 when Paul Maritz, a manager at Microsoft, reportedly used the phrase "Eat your own dog food" in an email asking coworkers to increase their use of Microsoft products for their internal work.
• Another origin story for it comes from Kal Kan Food, Inc. (A pet food company), where the company’s president reportedly ate his own dog food during board meetings with shareholders.

Here are a few examples where software companies used dogfooding:

• BetterBugs.io uses its own product for visual bug reporting, bug tracking, debugging, and bug management to improve it further and fix any issues that arise.
• Microsoft has an Outlook Dogfood app that allows its employees to test the latest version of the app before it is released to end users.
• Meta’s open-source frontend UI library, React, is another great example of it. It mentions dogfooding as one of the most reliable ways to check a nearly finished product or feature before shipping it to production.
• Google describes dogfooding as an integral part of the launch and certification process for its payment app Google Pay.
• JetBrains says that dogfooding has played a central part in their product-building process for many years.

Here are a couple of examples of how companies dogfood:

How BetterBugs.io Do Dogfooding 

BetterBugs.io is a visual bug-reporting tool with AI debugging capabilities. Here’s how we use dogfooding for further improvement of the product:

Creating Visual Bug Reports

BetterBugs employees utilize the tool to create comprehensive bug reports with annotated screenshots and video recordings. This ongoing process ensures prompt reporting of bugs, leading to polished feature or version releases before they reach external users.

Capturing Frontend and Backend Logs for Debugging

BetterBugs auto-captures technical details of issues, such as console statements, network logs, and system information, attaching them to bug reports. Additionally, it includes backend event logs from Sentry and fullStory infrastructures, enabling our QA and development teams to resolve issues swiftly.

AI Debugger

Our AI debugger assists our development teams in debugging issues with AI-generated reproduction steps, impact analysis, and diagnosis, thereby using our own product as dogfood.

Integration Capabilities

BetterBugs integrates seamlessly with popular project tools and issue trackers like GitHub, Jira, and Asana. Our team leverages this integration feature to report bugs directly to their respective workspaces.

Feedback Mechanism Across Teams

The ease of use allows members from all departments—QA, developers, support teams, project managers, and marketing—to use BetterBugs.io as their primary bug-reporting tool. This ensures that everyone can contribute to the continuous improvement of the product-building process.

How JetBrains Do Dogfooding 

Here are some examples of how JetBrains makes dogfooding integral to their product development culture. 

Repository Management 

JetBrains uses its own platform, JetBrains Space, to manage its huge code repository using Git. Space is a software development platform similar to GitHub, boasting features like Git Hosting, Code Reviews, CI/CD pipelines, and others. 

Using Nightly Stable Builds of IntelliJ IDEA

JetBrains uses its master branch for ongoing development, unlike several other companies that typically prefer developers to contribute through separate feature branches. This enables them to make nightly builds of their in-house product IntelliJ IDEA available to employees right off the bat. Stable versions of the tools are created six weeks before the public rollout, allowing them to iron out issues beforehand. There are also weekly release branches for Early Access Programs (EAP) and bugfix updates. 

Setting Up Local Dev Environment

For employees who need to install everything on a fresh computer, JetBrains has an in-house ToolBox App. This app can be used as a launchpad for internal employees to access all work-related software from one place. They can also clone or open projects within the app. Specifically, it’s called the IDE Provisioner for managing IntelliJ-based IDEs. It’s an enterprise product that makes all developer tools accessible for internal usage by JetBrains and as well as other companies.

Using Internal Build Tool for Project Setup

As per the company, the entire IntelliJ project, containing over 2600 modules, is built using JPS (JetBrains Project System), which is IntelliJ’s internal build tool. While most Java projects use typically Maven or Gradle in some form, IntelliJ uses its own system for Java-based builds allowing them to work with their own framework and fix issues independently without relying solely on external tools.

Shared Indexing Plugin

JetBrains has a plugin for shared indexing (which allows finding inheritors and build calls in a project) of JDKs and libraries. For this, JetBrains has a product called TeamCity (it’s a CI/CD platform) for indexing monorepo source code that enables them to complete project indexing in under a minute. JetBrains uses the same product for indexing its own projects.

JPS Caches Plugin

JetBrains has an experimental feature as an in-house plugin called JPS Caches that allows the internal team to create incremental builds of their tools using the CI servers. While this feature isn’t fully ready for external users yet, internal employees are using it. 

Here are some common misconceptions about dogfooding with explanations to clarify things:

It’s Only for Pre-launch Products

Some might think of dogfooding as mostly a pre-launch thing, but as described, it’s actually an ongoing practice. Using the product continuously helps teams spot issues and improve user experience, ensuring the product evolves based on real feedback.

It Means Using the Product Perfectly as Intended 

The core idea is to experience discomfort firsthand and identify friction points allowing you to focus on several aspects from an end-user perspective, including product onboarding, setup, and usage.

Only Developers Should Participate in Dogfooding

Apart from developers, it’s crucial to involve people from QA, management, marketing, sales, and customer support allowing you to get diverse perspectives.

It Guarantees a Successful Product

While it certainly does improve product quality, external feedback is crucial, as relying solely on internal use can lead to complacency and blind spots.

It Eliminates All Risks Associated with a Product Launch 

While it helps identify many issues, it can’t catch every problem or predict all user reactions. Besides this, thorough market research and traditional QA methods are still necessary beyond internal use.

Here’s a list of best practices you can borrow to get the most out of dogfooding.

Create a Dedicated Dogfooding Team

Start things off by designating a team that can coordinate and manage the dogfooding process. This team should:

• Ensure that interested employees are actively participating.
• Provide timelines.
• Collect feedback through proper channels, such as thorough emails or bug-reporting tools.
• Track reported issues using issue trackers.
• Summarize and hand off the final report documents to the teams responsible for managing issues.

Work on Realistic Scenarios

Ensure that the internal usage of the product replicates real-world scenarios that end-users might come across in everyday product usage. Some issues that it helps identify include:

• Bugs and glitches.
• Usability and user-experience issues.
• Integration problems.
• UI flaws.
• Performance issues.

Ensure Proper Feedback Mechanisms

Ensure a company culture where employees can feel comfortable providing honest and constructive feedback. Besides this, what works best is  establishing clear feedback loops with:

• Regular meetings.
• Anonymous surveys.
• Open-door policies.

Document and Track Issues

Maintaining detailed logs of all reported issues and feedback works best. Moreover, make sure that bug-reporting tools, logger tools, and issue trackers are in place. 

Iterate and Make Improvements

Iterate on the product based on the feedback received during dogfooding. Using the feedback,

1. Make improvements 
2. Test again
3. Repeat the process until the product is ready for public rollout.

Communicate Insights and Findings

Share the insights and improvements from dogfooding procedures with the relevant team members to ensure that everyone's on the same page on the product's progress.

While dogfooding numerous benefits, there are some potential pitfalls to be aware of, such as:

• Biases — If you become too comfortable and confident with the product—since you were involved during the development and testing phases—you may not thoroughly test all features and functionalities from an end-user perspective. And this could backfire.
• Overlooking external feedback — Relying solely on internal feedback can result in missing out on valuable insights from actual users. Balancing dogfooding with traditional testing methods coupled with external beta testing works best.
• Ignoring negative or unexpected feedback — It's crucial to address negative feedback and not dismiss it as mere complaints. Negative feedback often highlights critical areas that require improvement in at least some form or the other.
• Misalignment with the actual users — If the internal team does not accurately represent the target audience, the feedback may not be fully relevant.