Three months ago, I stepped into a journey I never imagined would shape me this much. Today, as I sit here right after my final evaluation meeting with my mentors, my heart is full, a mix of gratitude, pride, and excitement. I’m Tasneem, a student from Egypt, and this is the story of my journey with Galasa, and how my mindset evolved along the way.
Make sure to read my midterm post to know how it all started. For now, let’s focus on how things are ending.
Galasa: Introducing the Web UI
Galasa now has its missing piece – the Web UI. This new interface allows users to view test runs, artifacts, and logs without the need to download large files to their systems. With the release of Galasa 0.43.0, the test runs interface became available for real users to try out for the first time. While some parts are still experimental, the Web UI has already matured into a practical tool and continues to expand its capabilities.
Galasa itself is an open-source testing framework that helps you easily test complex systems, whether they’re running on the cloud, mainframes, or both. It’s designed to run tests locally on a developer’s laptop, in a CI/CD pipeline, or by delegating test execution to the Galasa Kubernetes-hosted service, where each test connects remotely to the system under test.
Throughout the mentorship, my main goal was to see the Web UI become fully functional for users. I worked on various stories to enhance the overall experience. The first two months were focused on building the main Web UI and completing the core mentorship task, while the last month was dedicated to enhancing the Web UI and adding more features to it.
Looking ahead, the Web UI will go even further, it will not just be about viewing test runs, but also about managing them. Features like running, cancelling, and deleting test runs are planned, making the Web UI an integral part of the Galasa ecosystem.
So, what does all this look like in action? Let’s take a quick tour of the Web UI
You can also refer to my final presentation video to see how Galasa evolved over the past three months and where we’ve reached today.
Reflecting on the Journey
One of the most valuable parts of this mentorship was experiencing how a professional software engineering team works. Our process followed Agile development practices: we had daily scrum meetings, iteration planning sessions, raised stories, and linked pull requests to them. Everything flowed smoothly, and for me, it was the first real experience of being part of such a well-structured team.
One key lesson was that not everything is about code. Beyond writing code, the most important part of the process is keeping a mindset focused on making things work better. Story reviews, code reviews, and documenting each small step in the project were just as important as coding itself.
Story and Code Reviews
During our retrospective meeting, where we reflected on what went well and what could be improved, I suggested we “review stories more.” My mentors responded by introducing a new team meeting every two weeks dedicated to story reviews. This small recognition made the coding process faster, since we no longer had to stop in the middle of implementation to clarify story details, we had already gone through them thoroughly and even contributed to shaping them.
At my final evaluation, my mentor told me, “You changed the way we work.” That moment showed me how even small ideas can improve the way a team collaborates.
Another important thing I learned during this mentorship was the value of reviewing others’ code. Seeing the difference between code before and after a review really opened my eyes to how impactful this process is. It’s not just about catching bugs, it’s about sharing knowledge, spotting cleaner solutions, and making sure the team is building things in the same direction.
Sometimes I learned just as much from reading my mentors’ comments on my pull requests as I did from writing the code itself. Other times, by reviewing someone else’s code, I picked up techniques and patterns that I could then apply in my own work. It stopped feeling like I was just “checking” someone’s code and more like I was actually getting familiar with it, which made jumping onto a feature after someone else so much easier. Over time, I even started to enjoy reviews almost as much as writing code (yep, never thought I’d admit that).
Don’t Leave Without Documenting Your Work
One of the biggest lessons I learned is how important documentation really is. When you’re working on a project that others will continue after you, clear documentation isn’t just nice to have, it’s what keeps your work alive. It makes sure that what you built can keep growing and improving long after you’ve moved on.
I felt this most when working on non-trivial solutions that future features would need to interact with, like:
Unit Testing: Slowing Down to Speed Up
When I first started taking on tasks, I noticed that every single story included the line “Add unit tests.” At first, writing tests, especially for parts with a lot of logic rather than simple UI rendering, felt like it slowed down the coding process.
Does unit testing take time? Absolutely. But its real value doesn’t show up right away. It becomes clear once the codebase grows, and suddenly a small change in one place can break functionality in another. The confidence tests provide, and the bugs they prevent, make the time investment more than worth it.
In the end, I stopped seeing unit tests as an “extra task” at the end of the story. They became part of the development process itself, just as essential as writing the code they were testing.
Parting Thoughts
I dedicated this blog post to show how the mentorship shaped me beyond the technical skills. Of course, there’s no way to capture all the challenges I faced with complex problems, the testing I did, and how I grew technically. But the highlight for me is learning how to be a better developer, a good teammate, and someone who truly enjoys what she’s doing and makes the most out of it.
I’m really thankful for the past 3 months, and for being part of the Galasa team,I’ve learned so much from them. Big appreciation to my mentors, Mike Cobbet and Eamonn Mansour, for giving me this valuable experience and for being patient with me constantly “questioning things.”
This mentorship wasn’t just about writing code for me, it was about growing, working with amazing people, and realizing how much I enjoy being in this field. I’m walking away not just with new skills, but with memories and lessons I’ll carry with me for a long time.
