There are many types of testing and we will eventually introduce those, but the simplest place to start is Front End (UI) manual and automated testing.
Front End – means a GUI running in a browser.
UI – means we are testing that the primary focus is on how the user and the UI interact, without much focus on what happens after the page is submitted to the backend.
Manual – means that the tester is simply using the UI with a keyboard and mouse and observing the display to make sure it shows what it is supposed to show.
Automated – means that that same testing is captured by a tool that records the details of the interaction in such a way that it can be repeated over and over and re-tested after any code changes are made.
I have found what looks to be a good introductory course on frontendmentor.io: Welcome to the front-end testing learning path. Read at least the first page of that learning path, then return here and leave some comments about:
- Before this reading, did you imagine that in-depth UI testing would be tedious and random “just poking around”?
- What do you think now?
- What did you read that makes you want to test?
- What might you discover about our dog food if you did this kind of testing?
Next Page -> Special Challenge for Cohort-3 – Intro to testing.
Before this, I did not really know what UI testing was. I also could not open the lesson on *Frontend Mentor* because it said I have not unlocked that level yet. So I went on Google to understand. At first, I thought testing was just random clicking.
Now I think UI testing is serious and organized. It is about checking your own product carefully, like the idea of “eat your own dog food.” You use your own app and feel the real problems.
What made me want to test is this idea. When you use your own product, you see real issues. It is not theory. It is real experience, and it helps improve quality.
If I test our dog food (our own app like the student survey app), I can find many problems. Maybe the form is hard to fill, or buttons are not clear. Maybe the flow is confusing. Since I am also a user, I will feel the problems and want to fix them fast.
All of this will further not only allow me to test my own work, but also other people’s work.
Practically, it is kind of what our mentors are doing right now with the challenges from Frontend Mentor
Before reading this, I used to think that UI testing was mostly tedious and somewhat random, like just clicking around to see if things break. It didn’t seem very structured or strategic.
Now, I see that front-end testing—especially when done properly—follows a clear methodology and can be very systematic. The distinction between manual and automated testing also helped me understand how testing can evolve from simple interaction checks to repeatable and reliable processes.
What motivated me the most is the idea that automated testing can save time in the long run and ensure consistency after code changes. It makes testing feel more like a powerful tool rather than a boring task.
If I applied this type of testing to our own “dog food” project, I think I could uncover several usability issues, such as broken UI elements, inconsistent behavior across pages, or unclear user flows. It would also help identify edge cases that are easy to miss during normal development.
Overall, this changed my perspective on UI testing—it’s not just about clicking randomly, but about understanding user interaction and ensuring a smooth and reliable experience.
Before reading this, I saw UI testing as a tedious task. Now, I understand it’s an opportunity to ‘eat our own dog food’ and discover illogical flows. Automating these scenarios allows us to stop enduring the testing process and instead make it an ally for delivering faster with more confidence.
Nice.
Before, I saw UI testing as just random clicking without structure. Now I understand that it is a real method where we analyze the application like a real user to find problems. The idea of “eat your own dog food” shows that we should use our own product to better detect issues and improve the user experience.
Before this reading, UI testing felt like random poking around and honestly a bit tedious. Now I see it as a structured and purposeful process, especially with unit, integration and end-to-end testing guiding it. What stood out is how testing gives real confidence in your work and improves user experience that actually motivates me to test more. If we applied this to our own “dog food,” we’d likely uncover hidden bugs, unclear user flows and small issues that only appear when the product is used like a real user would.
I have to admit that UI testing for me felt like random clicking, just trying things, boring, and repetitive, or something testers do, not developers. After reading this article, UI testing now feels like exposing hidden friction, simulating real user journeys, or validating assumptions.
I used to think UI testing was just breaking thing for the sake of it, or chore left for someone else.
but I’ve realized it’s actually the ultimate reality check. moving from random clicking to a structured approach, specially when you eat your own dog food, turns testing int a design tool rather than a but hunt.
it’s the difference between knowing your code works an knowing your product actually feels right to use.
On a side note, it looks like I didn’t have access to the specific Frontend Mentor article mentioned, so I wasn’t able to read the first page of the learning path myself. However, I’m ready to dive into the discussion once we start identifying those specific discovery points and applying them to our current projects!
It’s a great starting point to focus on the GUI, as that is the first line of defense for user experience. The distinction between manual exploration and the repeatability of automated testing is key; moving from poking around to a structured learning path on Frontend Mentor should help us turn what often feels like a tedious task into a reliable, professional workflow. I’m especially interested to see how applying these automated tools to our own dog food will reveal those subtle UI regressions that are easy to miss when testing manually.
Before, I thought UI testing was just “clicking around” to see if things work. Now I understand there is real structure behind manual testing, and automation makes it more reliable and repeatable. It actually makes me want to look at interfaces differently.