My First Microservices Project: Automating QTP at Brightside

Before microservices became the buzzword they are today, I found myself stumbling into that architectural world out of necessity—not trend. It happened at Brightside, where one of my first significant engineering challenges was rethinking how we approached automated testing with QTP (QuickTest Professional).

At the time, our QTP tests were cumbersome and time-consuming. Everything ran sequentially, with no parallelism or scalability. It didn’t take long to realise we were bottlenecked by our own tooling. I saw an opportunity to reshape the testing strategy and pitched a solution based on distributed execution.

The idea was straightforward: what if we could distribute the QTP tests across multiple machines and coordinate execution in parallel? What emerged was my first microservice-based system. I designed lightweight services responsible for initiating and reporting test execution. A central controller service handled scheduling and aggregation, enabling us to slice up the workload and execute tests concurrently.

It wasn’t perfect, and I learned a lot by trial and error. But it worked—and it delivered immediate value to the team. Test suites that previously ran overnight could now be completed within hours. More importantly, it introduced a mindset shift. Rather than accepting tool limitations, we began thinking about how we could reshape our environment to scale with us.

This project sparked my interest in service-based thinking. I saw firsthand how decoupling responsibilities, even within internal tools, could unlock flexibility and performance. It also taught me that microservices are not reserved for public-facing applications. They can be equally transformative in internal workflows.

Looking back, that early experience gave me a foundation in the principles that underpin distributed systems. I may not have known the terminology or patterns at the time, but I was learning the mindset—one that continues to guide how I architect systems today. The lesson was clear: architecture isn’t just about design patterns or diagrams—it’s about solving real problems in scalable, elegant ways.