3

Background: This is important in general for any testing but I think this is particularly more important in agile when a critical feature is on the line which needs to be released early for various business reasons. Coming up with important bugs early in the test process is then a vital and very practical approach to add value as a tester in the team.

As a professional tester what approach/techniques do you personally keep in your arsenal

to find important(business critical) bugs faster and early in the testing?

Note: Please answer this NOT based on opinion but based on facts per your actual experience working as a tester in actual projects in agile.

Basically please mention what actually worked for you!

Improve this question
0

7 Answers 7

Reset to default
4

Find Bugs Faster and Earlier:

All of the following have worked well for me in several companies:

Before test code or automation is even written:

  • Use well thought out test data strategies to ensure reliable repeatability for manual testing

  • Use extensive linting in application code to prevent likely bug situations in the first place

  • Have quality application code practices in place so that easily avoidable bugs are avoided

  • Use persona testing to reflect real world cases and scenarios and workflows from an actual users perspective

  • Talk through the test cases during backlog refinement and when initially preparing to work on the feature to ensure that tests, workflows and testable code are first class citizens

Once application code is being written:

  • Shift testing "left", i.e. more unit and less end-to-end

  • Make sure unit tests actually mock the database and network

  • Use Automation to run thousands of tests repeatedly and quickly

  • Use parallelization to run tests on multiple machines more quickly

  • Maintain high test coverage so regressions are spotted quickly and early during development

  • Use the test pyramid as a guide and focus on unit testing with mocked and stubbed dependencies

  • Use CI/CD practices to ensure tests are run consistently and code merging depends on them passing

  • Test at multiple levels (unit / integration / e2e ) to ensure bugs have a good chance of being caught early

Improve this answer
4
  • Thank you Michael. Although I believe all of the above are very good test practices in general but I think they don't directly relate to the question as mainly focused on automation. The very first cycle of testing is always manual as automation takes time however once its done , it saves lot of time in each successive test cycle.
    – Vishal Aggarwal
    Dec 29, 2022 at 11:16
  • @VishalAggarwal good point. I've updated the list and divided it into non-automation-code and automation-code sections.
    – Michael Durrant
    Dec 29, 2022 at 12:10
  • 1
    It is important to note that there are two distinct situations to cover - running tests against existing code to make sure it isn't broken by the new feature. This form of extensive regression testing of the existing code base is best done thru automation. The second situation - testing of new features - can be done manually in a more manageable fashion (but of course manual testing only makes sure it works 'today' and over time it will become impractical to test all the cases manually (due to the time it takes) and choices have to be made.
    – Michael Durrant
    Dec 29, 2022 at 12:16
  • Thanks Michael. A very good point!
    – Vishal Aggarwal
    Dec 29, 2022 at 12:50
2

Direct answer: The best tool I've used is strong familiarity and long experience with the product and its technology stack. Over time (meaning months, or years -- not days or weeks) you develop a kind of "acquaintance" with the product. You learn the areas where things break most often, when features are modified or added. This then leads you to the test cases you need to run first to catch any bugs in those areas.

Indirect answer: (i.e. now I'm questioning the question): Bug prevention is always, always better than bug detection, no matter how quickly or how early the test team catches those bugs. So also -- over time -- as you discover the areas of the product most prone to trouble, you should engage with the developers to see about re-architecting those areas to prevent the bugs you so quickly found.

Improve this answer
2
  • Thank you however I disagree as finding defects faster based on "strong familiarity and long experience" does not make one effective tester. A effective tester should be able to find defects faster in relatively new application as well based on his testing skills alone using the right approach and techniques.
    – Vishal Aggarwal
    Dec 29, 2022 at 11:40
  • The "right approach and techniques" will be radically different based on what is being tested -- and only experience (gained individually or shared through mentoring) can provide that insight. Consider the differences between testing a mass marketed game app for an Android phone, or testing an enterprise software system used by a large business to manage its accounting needs, or testing the embedded software used by a driverless vehicle. No tester, no matter how skilled, can immediately know the right approach and techniques for all those different kinds of systems.
    – JDM
    Dec 29, 2022 at 12:28
2

This is what kind of helped me in finding important bugs faster:

  • Understanding the "crux" of the feature usage from user perspective from user story/ exploratory testing
  • Modelling an diagram of the feature(end to end) highlighting key interaction points
  • Visually creating an data flow path
  • Identifying different states the feature can get in to and all possible different ways to reach them through UI/Backend
  • Ultimately convert all my understanding in to decision table format matrix to form specific test scenarios

And, and and questioning all along to solidify my understanding - asking the right questions to the right people in the right context.

enter image description here

Improve this answer
1
  • 1
    All good ideas with a broad application to most any kind of software or system. The emphasis on the end user (as per the 1st bullet) is especially helpful, as it will reveal the bugs most noticeable to the end users.
    – JDM
    Dec 29, 2022 at 12:37
2

Here are some approaches and techniques that testers commonly use to find important bugs faster and earlier in the testing process:

Risk-based testing: Identify the parts of the system that are most critical to the business or have the highest potential impact if they fail, and prioritize testing those areas.

Exploratory testing: This is a type of testing where the tester has a general idea of what to test, but does not have a specific set of steps to follow. This can be effective for finding unexpected bugs.

Pair testing: Pairing with another tester or developer to test the system can help find bugs faster as two sets of eyes are better than one.

Automated testing: Setting up automated tests can help catch regressions and ensure that critical functionality is working correctly.

Test early and often: The earlier a bug is found in the development process, the cheaper it is to fix. So it is important to start testing as early as possible and to continue testing throughout the development process.

Use debugging tools: Debugging tools such as debuggers and log analyzers can help testers identify and troubleshoot bugs.

Collaborate with the development team: Working closely with the development team and getting their input on where bugs are most likely to occur can help focus testing efforts and find important bugs faster.

Improve this answer
0

To create risk matrix while test an idea-documentation. Then make a list "how to avoid these possible bugs" or "accept a risk". In addition add columnn "How much that acception costs?" for accepted risks. Fill the column for every risk.

quality-oriented process works for me.

Improve this answer
0

It seems you are asking about advice for testing approach with feature testing on one project, not set of unknown projects. I have an assumption, that testers should have some experience with this project.

Short answer:

Really strong knowledge and huge experience with the project and its tech stack.

Long answer:

You should have right processes for all aspects of your project under the testing to have possibility to do quick and effective testing:

  1. Products provide clear AC(Acceptance Criteria).
  2. Developers implement this feature and cover them with Unit tests.
  3. DevOps provided proper pipelines to build and deploy this feature on testing envs.
  4. Start testing and test case creation ASAP as you get AC(before real implementation).
  5. Flexible and stable testing environment, that allows testers to focus on testing only, not infrastructure or environments troubleshooting.
  6. We can't find all bugs in short period of time, but we should find all blockers and critical bugs to fix them before actual release. I would focus on Critical path testing.

This type of testing focuses on functionality used by typical users in their daily activities. The idea itself is borrowed from project management and transformed in the context of testing: most users mostly use some subset of application features. These features need to be tested once we have ensured that the application works in principle (the smoke test was successful).

Improve this answer
5
  • 1
    please share any feedback if you vote down.
    – Alex Kulinkovich
    Dec 29, 2022 at 17:29
  • I think knowing an application deeply by using it over a long period of time does not equate effective testing skills.
    – Vishal Aggarwal
    Jan 4 at 1:51
  • 1
    Possibly I used the not right words for it. My main idea was about experience with tech stack and domain area of application under testing (is it just simple web site or some mobile app, or maybe something from AdTech ). Each of those areas has each own terminology, specifications and details. I ddin't have such cases in my working experience, that people without those key knowledge could find important bugs faster and early in test process. They definitely will find something, but it will take more time.
    – Alex Kulinkovich
    Jan 4 at 16:11
  • 2
    Knowing what the application is meant to do is important. Imagine testing a car's brake software without knowing about ice and snow. Imagine testing a statistics application without knowing statistics. How effective are your tests going to be?
    – C'est Moi
    Jan 5 at 12:07
  • 1
    @VishalAggarwal, you didn't ask "What are effective testing skills?" You asked "How can the most significant bugs be found quickly?" A deep knowledge of the application from long experience is a valid answer to that question, as my own experience has affirmed.
    – JDM
    Jan 11 at 12:39
0

As a professional tester, finding important and business-critical bugs early in the testing process is crucial for ensuring the quality and success of a project. Here are a few approaches and techniques I have found to be effective in my experience:

  1. Risk-based testing: Identifying the most critical areas of the application and focusing testing efforts on those areas first. This involves analyzing the application from a business perspective, identifying potential risks and ensuring that those areas are thoroughly tested.

  2. Exploratory testing: A hands-on testing approach where the tester has a general understanding of the application but does not have a predefined test plan. This approach can uncover important bugs early in the testing process as it allows the tester to think creatively and outside the box.

  3. Early involvement in the development process: By collaborating with the development team early on, testers can better understand the application and identify potential risks before the code is even written. This can lead to quicker identification and resolution of bugs.

  4. Automated testing: Automating repetitive tasks and regression tests can help identify important bugs early in the testing process. This allows testers to focus on higher-level, exploratory testing and uncover important bugs faster.

  5. Using the right tools: Utilizing the right tools can greatly improve the speed and effectiveness of testing. For example, using a bug tracking system can help prioritize and track bugs, and performance testing tools can help identify performance-related bugs early on.

A combination of these approaches and techniques can help a tester find important and business-critical bugs early in the testing process. It's important to continually evaluate and adjust these approaches based on the unique requirements of each project.

Improve this answer

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.