How Developers can Improve Testing Practices

Testers are often handed work too late in an iteration to test within the iteration. To fix this, reduce the size of handoff between programmers and testers. Instead of a programmer coding an entire product backlog item (typically a user story) and handing the whole thing over to be tested, the programmer should hand over small parts of an item as each is finished. Think about a typical product backlog item and its acceptance criteria. Let’s suppose it’s a user story with four acceptance criteria. As the programmer writes the code to fulfill each acceptance criterion, that work should be handed over for testing. This allows the programmer and tester to work nearly concurrently. Here’s how this would work for a simple user story about logging in: “As a member, I am required to log in so that my account is secure.” Let’s give it acceptance criteria of: ✅ The right credentials grant access ✅ The wrong credentials deny access and display an error message ✅ A user can request a password reminder, and ✅ A user is locked out after 3 failed login attempts The programmer and tester decide to start with granting access when the right credentials are entered. While the programmer writes the code to support only this, the tester creates a test plan and test data for just this small part of the full story. Depending on how much automation is already in place, the tester may even be able to script automated tests that will run as soon as the code is available. As soon as both the programmer and tester are done, they check their work into the official build system and the tests are run. They then agree on what to work on next. Let’s say they choose the bit allowing users to request a password reminder, another of the story’s acceptance criteria. Again, while the programmer codes support for just this, the tester creates test plans, test data, and automation scripts. There are still handoffs between the programmer and tester. But instead of one big handoff of the entire product backlog item, the programmer is handing work to the tester one small subset of the full feature at a time. For this to work, the programming and testing tasks don’t need to take the same amount of time. Coding could, for example, take twice as much time as getting tests ready to run. In that case, the same tester could be following a similar pattern with a second programmer, or doing any of a myriad of other testing tasks. Reducing the size and increasing the frequency of handoffs will solve the problem of testers not having time to test.

One of the most impactful changes I've seen in quality happens when you implement one specific process: a 30-minute QA-Dev sync meeting for each feature before coding begins to discuss the implementation and testing strategy. When I first bring this up with a client, I get predictable objections: Developers don’t want to "waste" their time. Leadership doesn’t want to "lose" development time. Testing is necessary anyway, so why discuss it? Our QA doesn’t couldn't possibly understand code. The reality is that the impact of effective testing can be remarkably hard for an organization to see. When it goes smoothly, nothing happens — no fires to put out, no production issues. As a result, meetings like this can be difficult for leadership to measure or justify with a clear metric. What confuses me personally is why most engineering leaders say they understand the testing pyramid, yet they often break it in two, essentially creating two separate pyramids. Instead, you should have a collaborative session where QA and Dev discuss the entire testing pyramid — from unit tests to integration and end-to-end tests — to ensure comprehensive and efficient coverage. Talking through what constitutes effective unit and integration tests dramatically affects manual and end-to-end testing. Additionally, I'm continually impressed by how a QA who doesn’t "understand" full-stack development can still call out issues like missing validations, test cases, and edge cases in a method. QA/Devs should also evaluate whether any refactoring is needed, identify potential impacts on existing functionality, and clarify ambiguous requirements early. The outcome is a clear test plan, agreement on automated and manual checks, and a shared understanding that reduces late-stage bugs and improves overall product quality. #quality #testing #software

𝗙𝗶𝘅𝗶𝗻𝗴 𝗯𝘂𝗴𝘀 𝗶𝘀 𝗵𝗮𝗿𝗱. 𝗙𝗶𝘅𝗶𝗻𝗴 𝘁𝗵𝗲𝗺 𝙧𝙞𝙜𝙝𝙩 𝗶𝘀 𝗲𝘃𝗲𝗻 𝗵𝗮𝗿𝗱𝗲𝗿. That's why I’ve consistently used this approach with my teams—whether building Smart TVs or modern Software-Defined Vehicles (SDVs): 🪛 𝗦𝘁𝗲𝗽 𝟬: Reproduce the issue manually. Understand the problem first. 🧪 𝗦𝘁𝗲𝗽 𝟭: Write a failing automated test that reproduces the bug. Aim for a unit test. 📦 If not possible, go for an integration test. 🧰 As a last resort, use a system-level test. 🔍 𝗦𝘁𝗲𝗽 𝟮: Debug and locate the issue in the code. ✅ 𝗦𝘁𝗲𝗽 𝟯: Fix the bug and make the test pass. 🧼 𝗦𝘁𝗲𝗽 𝟰: Refactor and clean up if needed. This method has saved us countless hours—and more importantly, it gives us automated 𝗿𝗲𝗴𝗿𝗲𝘀𝘀𝗶𝗼𝗻 𝘁𝗲𝘀𝘁𝘀 for free. That bug? It’s not coming back. Thanks Daniel Moka for the crisp reminder of this battle-tested approach. Works in every domain I’ve touched. #TDD #EmbeddedSystems #SoftwareQuality #SDV #Testing #DevPractice #BugFixing #RegressionTesting

𝐈𝐬 𝐲𝐨𝐮𝐫 𝐭𝐞𝐚𝐦 𝐬𝐭𝐢𝐥𝐥 𝐭𝐞𝐬𝐭𝐢𝐧𝐠 𝐬𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐚𝐭 𝐭𝐡𝐞 𝐞𝐧𝐝 𝐨𝐟 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 𝐜𝐲𝐜𝐥𝐞𝐬? You might be missing out on a crucial strategy that could streamline your processes. 😨 𝐑𝐞𝐭𝐡𝐢𝐧𝐤𝐢𝐧𝐠 𝐰𝐡𝐞𝐧 𝐭𝐨 𝐢𝐧𝐭𝐞𝐠𝐫𝐚𝐭𝐞 𝐭𝐞𝐬𝐭𝐢𝐧𝐠 𝐟𝐨𝐫 𝐨𝐩𝐭𝐢𝐦𝐚𝐥 𝐞𝐟𝐟𝐢𝐜𝐢𝐞𝐧𝐜𝐲 Holding off on integrating testing until the later stages of development is a common practice, but it may actually cost more in terms of time and quality. 𝐁𝐞𝐧𝐞𝐟𝐢𝐭𝐬 𝐨𝐟 𝐞𝐚𝐫𝐥𝐲 𝐭𝐞𝐬𝐭𝐢𝐧𝐠 𝐢𝐧𝐭𝐞𝐠𝐫𝐚𝐭𝐢𝐨𝐧: ➡️ 𝐂𝐥𝐚𝐫𝐢𝐟𝐲𝐢𝐧𝐠 𝐬𝐩𝐞𝐜𝐢𝐟𝐢𝐜𝐚𝐭𝐢𝐨𝐧𝐬 𝐟𝐫𝐨𝐦 𝐭𝐡𝐞 𝐬𝐭𝐚𝐫𝐭: Starting with testing helps pinpoint and resolve specification issues early, drastically cutting down the usual 55% of engineering time spent on rework due to misunderstandings. ➡️ 𝐄𝐧𝐬𝐮𝐫𝐢𝐧𝐠 𝐜𝐨𝐦𝐩𝐫𝐞𝐡𝐞𝐧𝐬𝐢𝐯𝐞 𝐜𝐨𝐯𝐞𝐫𝐚𝐠𝐞: Implementing testing from the get-go ensures all aspects of the software are covered, reducing the risk of major issues during later stages. ➡️ 𝐓𝐮𝐫𝐧𝐢𝐧𝐠 𝐭𝐞𝐬𝐭𝐬 𝐢𝐧𝐭𝐨 𝐥𝐢𝐯𝐢𝐧𝐠 𝐬𝐩𝐞𝐜𝐢𝐟𝐢𝐜𝐚𝐭𝐢𝐨𝐧𝐬: Tests developed at the beginning of the project cycle guide the development process, acting as a dynamic blueprint that enhances clarity and focus across the team. Shifting to early testing integration optimizes your development process and significantly reduces time spent on debugging and revisions. This approach has helped our clients reduce engineering time by 35%, boost efficiency, and speed up time to market. 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 𝐲𝐨𝐮𝐫 𝐭𝐞𝐬𝐭𝐢𝐧𝐠 𝐭𝐢𝐦𝐞𝐥𝐢𝐧𝐞𝐬 Is delaying testing really the best approach for your projects? Consider integrating testing earlier to improve efficiency and enhance output quality. #SoftwareDevelopment #QualityAssurance #AITestingTools