How to find 50% software defects without testing?

Transforming from Pyramid to Diamond Software Testing

Let me start from a story.

About 20 years ago, I stepped outside an office building for a break when my colleague, Hank, approached me. He asked if I was from Department A, which made me wonder if something was wrong. He reassured me that wasn’t the case—he was simply astonished that my close colleague had discovered a call loss bug through a simple code review. This defect had gone undetected even after a million test runs by an automated call machine. I confirmed his assumption and mentioned that most of my department had a similar level of expertise in code reviews. That conversation marked the beginning of our friendship, and we later worked together on another successful product.

In the era of agile product development, the pace of iterations is much faster than traditional approaches. To accelerate the testing process and shorten time-to-market, various static and analytical techniques can be used to detect software defects without physical testing (i.e., without running the software on actual hardware). Shift-Left testing is a popular strategy, but it can be implemented in a more proactive and efficient manner for even better results.

As shown in the diagram, the Shift-Left method is highly effective because it follows two key principles in the product development process.

• Defect fix cost is 10x of previous phase
• The earlier to find defects, the less cost to fix defects

It helps alleviate late-stage testing pressure and prevent delays in software delivery. However, it can be made even more effective. By incorporating a few earlier stage activities to detect defects, both the defect injection peak and defect detection peak can be optimized. This approach is: Diamond Software Testing Model.

Requirement Review

• Understand product and software requirement, especially what does it means to users?
• Raise product and software testability requirements if missing. This will improve integration test, system test, and robust test efficiency in late phase.
• Techniques include formal requirements modeling and specification-based analysis.

This phase may not uncover many defects, but even a few can significantly impact later stages. Moreover, it serves as a critical input for system testing and robustness testing.

Design Review

• Validates software design and logic before implementation.
• Experienced reviewer may detect wrong or improper design including development tools choice, architect mismatch, resource conflicts, and low performance. It may avoid roll over from the very beginning during implementation.
• Verify if testability requirements are considered and designed as expected.
• Build up a foundation for next phase: pair programming and code review.

In normal case, if the software is well-designed, defect injection should be minimal. However, if defects exceed expectations or your team's baseline, it signals a problem that requires immediate action. Unit and integration tests depend on these designs to ensure code coverage and effective cross-module collaboration.

Pair Programming

Pair programming is a collaborative coding practice where two developers work together at one workstation. One is the driver (writes the code), while the other is the navigator (reviews the code in real time).

·         The navigator continuously reviews the code as it is written, catching syntax errors, logic flaws, and potential bugs before they become embedded in the codebase.

·         Two developers bring different experiences, leading to better identification of potential edge cases or overlooked scenarios.

·         Junior developers can learn from seniors while still contributing fresh perspectives.

It helps to catch bugs early as instant feedback. It also enforces writing cleaner, more readable, and well-structured code for a better code quality. In a well-organized pair, about 15% defects will be found. This is amazing point you can see and start to believe the answer. But the magic is yet to come.

It helps catch bugs early by providing instant feedback while also promoting cleaner, more readable, and well-structured code, leading to better overall quality. With a well-organized pair, around 15% of defects can be identified — an impressive result that reinforces the value of this model. But the real magic is yet to come.

Code Review

Code review is a systematic examination of source code to identify bugs, improve quality, and ensure adherence to coding standards before deployment.

• Peer reviews help identify logical and functional errors, incorrect assumptions, and security vulnerabilities.
• Reviewers ensure that the code properly handles exceptions, null values, and unexpected inputs.
• Catches Performance Issues: Reviewers can identify inefficient algorithms, unnecessary database queries, or excessive memory usage.
• Improves Code Readability: Ensures consistent coding style, clear variable names, and proper documentation, reducing technical debt.

This is one of the most effective techniques, capable of catching around 30% of defects without physical testing. However, its success depends on several key factors: a clear quality goal, strong leadership commitment, process support, proper organization, and the necessary expertise. Mastering this approach requires careful balance and execution. A more detailed article on this topic is planned for the near future.

I won’t be covering unit, integration, system, or robustness testing, as these are well-established traditional testing activities. However, this doesn’t mean they are unimportant or unnecessary—they play a crucial role in carrying the process forward.

What’s worth highlighting is that by implementing the earlier activities, around half of the defects should already be detected and resolved. This significantly reduces the pressure on unit, integration, and system testing. As a result, product development leaders can feel a sense of relief and gain confidence in the remainder of the software release journey.

By transforming from the traditional pyramid model to the diamond model, a new and optimized defect detection curve emerges. The diamond model introduces Just-In-Time Software Testing, where every development step is immediately followed by an effective testing step. When these steps align, they create a streamlined process that delivers high-quality software on time and at a lower cost. That is every product development team ‘s dream.

May your dream come true!