Introduction
Quality assurance isn’t just a box to tick at Lightflows – it’s a cornerstone of everything we deliver. Every digital product that leaves our workshop undergoes thorough testing to make sure it meets both functional requirements and looks spot-on before reaching our clients’ hands.
Like many digital teams, we’ve relied on Jira, Atlassian’s go-to platform for bug tracking and project management. It’s brilliant for helping teams log, track and sort software issues in an organised way, making it essential for software and product teams everywhere.
Jira works wonders for tracking development, but we noticed a snag in our process: traditional text-based QA reports were creating bottlenecks. Our testers would craft detailed descriptions of bugs, developers would interpret them (sometimes missing the mark), and then we’d go back and forth with questions before landing on a fix. The whole cycle felt clunky and sometimes frustrating.
We decided to shake things up and try Loom – a video-based communication tool – to see if it could breathe new life into our QA workflow. What began as a small experiment quickly became a game-changer for our entire process. Here’s our journey with Loom and why it’s now an essential tool in our kit.
The challenges of traditional QA processes
Before Loom entered the picture, our QA process looked rather conventional. Testers would manually log bugs in Jira, often writing lengthy descriptions that tried to capture complex issues. They’d add screenshots or mark them up, but these only offered a snapshot without the full context of the problem.
Developers would then read these tickets and frequently need to ask for more details, leading to a time-consuming back-and-forth. Meanwhile, our project managers tried to track progress, but without seeing the issue directly, miscommunication sometimes created inefficiencies.
As one team member put it:
“Manually writing notes about what you’re seeing, what element you’re interacting with on the page, and turning that into words is time-consuming. Turning what you’re seeing on screen into written words is incredibly time-consuming – explaining which element you’re clicking, what’s happening afterwards, and all the little details that matter”.
From our developers’ side, the frustration was just as real:
“Reading someone else’s bug notes can be like a guessing game. Sometimes the wording isn’t precise enough, and we end up having to make educated guesses about what’s going wrong.”
While Jira gave us the structure we needed, the way we logged issues wasn’t as efficient as it could be. Project timelines would stretch if multiple rounds of clarification were needed, leading to frustration all around.
How Loom changed our QA Workflow
We actually started using Loom for something quite different – creating internal documentation and standard operating procedures. But we quickly spotted its potential: if video worked so well for training, surely it could transform our bug reporting and QA feedback too.
Rather than drafting paragraphs of text, our testers could now record their screens while talking through the issue, making problems immediately clear. They could show mouse clicks, interactions, and animations – all those tricky elements that screenshots struggle to capture. Most importantly, they could explain their thought process in real-time, adding invaluable context for our developers.
The impact was immediate. As one developer put it:
“With Loom, I see exactly what the tester sees. It’s like having them sitting next to me pointing at the screen and explaining the problem – it’s so much more helpful than trying to decipher written notes.”
This approach dramatically cut down on miscommunication and made it easier for developers to understand issues without playing email ping-pong.
Our new streamlined workflow now looks like this:
Our QA process now flows much more smoothly. We start by recording the bug report with Loom, capturing both screen interactions and verbal explanations. Loom automatically generates a transcript of the video, giving us a text version as well.
We then use AI tools like ChatGPT to pull out key takeaways from the video, creating a concise summary. This summary, along with the Loom link, gets attached to Jira so project managers still have written records and can track progress.
This approach gives us the best of both worlds – detailed visual explanations alongside structured tracking within Jira. The simple change has transformed our QA efficiency, cutting out unnecessary back-and-forth and making bug reports clearer and more actionable.
The impact on our QA team
Since bringing Loom into our bug reporting process, we’ve seen significant improvements across the board. Testers now spend less time writing reports and more time actually testing products. Developers understand problems immediately, leading to quicker issue resolution. Even non-technical team members and stakeholders can review issues without confusion.
One of our testers summed it up perfectly:
“Since switching to Loom, I spend way less time logging issues and more time doing what I’m meant to – finding bugs and improving our products”
From our project managers’ perspective:
“Jira remains our single source of truth, but having Loom videos attached to tickets makes everything clearer. Everyone understands what’s happening, and it speeds up the entire process”.
The future of QA at Lightflows
We’re always looking to sharpen our processes, and Loom has been a massive win for our team. Moving forward, we’re exploring ways to make things even better – could AI help generate even better summaries? Are there ways to streamline Loom further in our workflow? We’re also refining our Loom recording techniques to ensure every video provides maximum clarity.
Learning and useful tips
Through trial and error, we’ve discovered that our video feedback works best when we keep a few principles in mind. Speaking clearly and logically while recording is crucial. Working through issues step by step provides clear context – we try to focus on just a handful of issues at one time, generally on a single page. We’ve also found that summarising key actions at the end of each video helps highlight the main takeaways.
Key takeaways
- Loom enhances bug reporting in Jira by making them more visual, reducing the need for lengthy written descriptions.
- Our Developers understand and resolve issues faster with video-based feedback.
- By using Loom and Jira together, we create an efficient, streamlined QA workflow that speeds up development cycles.
- Using Video communication minimises miscommunication, making it easier for our cross-functional and remote teams to collaborate.
Final thoughts
Loom hasn’t replaced Jira for us – it’s enhanced it. By adding video to our bug reports, we’ve removed ambiguity, improved collaboration across our teams, and saved time for everyone involved. The combination of Jira’s structured tracking with Loom’s visual clarity has created a QA process that’s faster, clearer, and more effective.
If your development team struggles with slow or unclear QA processes, we’d highly recommend giving Loom a try. For us, it’s moved from “nice-to-have” to “can’t work without it” status in delivering top-notch digital products to our clients.
