What?
There is an expression: “We eat our own dog food.”
The link on that statement leads to the Wikipedia Page about the origins of the term. What is crazy is that I remember seeing the dog food commercial in the ’70s. Now you are curious if you have not read it. If you read very far in that article you will see a number of examples of software and other companies (like Microsoft, Oracle, Apple) that have used that term to exhort their employees to actively use their own product while doing their job.
What is our dog food?
We have already trained the A-Team members in the use of UML Use-Case diagrams in the project contained in https://github.com/bahati7/MKB-cohort-2-Demo. That repository has a good README.md file and a doc directory containing UML markup for users and use case diagrams. That project was in preparation for the https://github.com/bahati7/student-survey-app project. That project has been completed and is live at Student Survey App Portal. Go visit those sites, as you will soon need to read them with a goal in mind.
Here is my challenge:
We are going to learn how to test UI and software in general by using our own products and processes to test our own software mentioned in the paragraph above. So, pay close attention to the details. We know how the users of that software use it because we are the users. Also, we will feel the pain of the issues with the UI, and will be motivated to fix those problems. We will be finding and reporting the usability issues, and then we will have to put on our developer hats and fix the problems.
Soon, there will be a new challenge added to our challenges page… and the details will be discussed there.
Next Page -> Front end testing
Getting a clue about the ‘eating our own food’ expression is a sensitive approach, allowing a development team to run and test their own product all along the process. This practice helps them not only deploy a quality of work but also a reliable and maintainable product.
It has been testified in the resources above, showing the impact of a company like Microsoft, Hewlett-Packard, on their product(Project Alpo), testing its own product.
This article introduces the concept of “eating your own dog food” in a very practical and engaging way. I find it especially valuable because it encourages developers to actively use their own products, which helps them better understand the user experience and identify real usability issues.
The idea of testing our own software as real users is powerful. It not only improves the quality of the product, but also builds empathy for users by allowing us to experience the same frustrations and challenges they might face. This approach naturally motivates developers to fix problems more effectively.
I also appreciate how the article connects theory (UML use cases and documentation) with real-world application through existing projects. It makes the learning process more concrete and meaningful.
Overall, this is a strong and practical approach to learning testing and improving software quality through direct experience.
The concept of “eating your own dog food” is very powerful, as it pushes developers to become real users of their own products. It helps bridge the gap between design and actual experience while building strong user empathy. By experiencing issues firsthand, we become more motivated to fix them. It’s a simple yet highly effective approach to improving both product quality and learning.
This is a great lesson in humility and accountability. If we aren’t able (or motivated) to use what we build, how can we expect our users to enjoy it? Using your own product is the ultimate truth test for validating the relevance of a feature.
i like this article. ❤️
I learned that “Eat your own dog food” means we should use our own applications as real users. In this way, we can directly see interface problems, usability issues, and errors. Then we report and fix them, which helps improve the software quality by better understanding the user experience.
“Eat your own dog food” highlights a powerful idea: if you truly use your own product you’ll naturally discover its strengths and weaknesses. It reminds me that real understanding doesn’t come from just building but from experiencing the product like a user. That’s where meaningful improvements begin.
Eating your own dog food highlights the idea that I must use the software I build the same way my users will, with real goals, frustrations, and habits. This is what I have to do based on this expression: stop making assumptions or saying this should be fine, or users will understand, and start experiencing missing feedback, unclear labels, or confusing pages.
Beyond empathy, using your own product radically transforms your technical judgment. As creators, we often justify complexity because the code is elegant or the architecture is robust.
But the moment we switch to the user’s perspective, that complexity is revealed for what it truly is friction.
When you live inside your own tool, you stop making excuses. If a workflow takes three extra clicks, you don’t just see it as a UI note you feel it as a disruption to your day. This personal frustration is the most powerful engine for simplification. In the end, the most valuable features aren’t the ones we add because they sound good in a meeting, they’re the ones we find ourselves relying on every single day just to get our own work done.
By using our own product, we stop seeing “bugs” and start seeing “problems for the user.” This motivates us to put on our developer hats and fix things properly.
As we test, we try to look at the app with “fresh eyes.” Since we already know how it works, it is easy to ignore mistakes. We try to act like a person who has never seen the app before. If something feels confusing to us, it will be even more confusing to a stranger. Let’s use this opportunity to turn a good project into a great one
By actively using our own Student Survey App and the MKB-cohort-2-Demo as testing platforms, we are effectively identifying bugs while experiencing the challenges of our user interface firsthand. This proactive approach transforms testing into a personal mission, making it impossible to overlook any usability issues. Because we navigate our own design, we can ensure that the solutions we implement as developers are grounded in real necessity rather than just theoretical concepts. This commitment allows us to create a more intuitive and effective user experience.
I like the idea of “eating your own dog food.” It makes things more real because you directly see the problems a user might face. I think it really helps to improve, since you are both the user and the developer.