According to the Standish Group’s Annual CHAOS 2020 report, 66 per cent of technology projects (based on the analysis of 50,000 projects globally) end in partial or total failure. However, this isn’t surprising when we think about how businesses are still managing their projects.

Many project management approaches to software engineering involves phases — each lasting months — before carrying out mostly manual testing right at the end of the project. Often, this occurs over a year since the initial project began. Even then, teams will repeat testing in cycles over several more months until all defects are eventually mitigated or accepted.

The challenges

This conventional approach to project management is deeply flawed and often results in projects being late, over budget and not delivering the expected value. Why? The answer’s simple.

Testing at the end means organisations are waiting months (sometimes years) to see if the software acts as expected. This creates a vastly delayed feedback loop, which gives software engineers little time to improve and update the product. Even if testing shows that the software is working as expected, there’s no real way of knowing if it delivers on the customer’s needs. This means more waiting before the engineers can even know that what they built is of any value.

Fast forward, it is now years after the customer first enquired. Not only have their needs probably changed, but so will the needs of the wider market. This means organisations risk a) missing out to a competitor that has developed a similar product, and b) delivering a software product that is no longer of use.

There are also logistical matters to consider. By the time the software reaches testing, the original developers may have left — rendering changes and maintenance even more challenging. Meanwhile, manual testing is time consuming and prone to human error, meaning bugs might be missed or incorrectly reported, and even small changes could take weeks to complete.

Why shift left?

Shifting left means bringing testing toward the early stages and putting it at the heart of the development process. Unlike the sequential model, testing early and often can help reduce the number of critical bugs during the deployment phase that require code patching.

This approach is best achieved by employing Test Driven Development (TDD) with CI/CD practices, where developers first write automated tests for the feature they are working on before writing the software to make the test work. Once teams have software that behaves exactly as they’ve defined, there are no surprises. Not only does this improve software testability, but it also means that the developer has a fully automated regression test pack developed at the same time. Therefore, the software is always fully tested and production-ready, the need for longer months-long test cycles is gone.

When developing large and complex software-reliant systems, software teams should break  development down into many daily increments. With each increment, the software is automatically deployed by a pipeline to the customer, made possible by shifting testing to the left.

Getting started

Implementing shift left testing means a huge culture change — businesses must encourage developers to take individual responsibility for their products and test what they build, meaning testing is no longer part of a separate team or role.

The biggest challenge in this process is management, because giving more time to developers to write tests is critical. Initially, it may seem that less work is being done and development is taking longer, but a holistic thinking is needed, requiring businesses to look at the  software as a whole across development, operations, testing, support and so on. For instance, the test phase itself will be eliminated, meaning there is a chunk of newly created time available. Meanwhile, tests are automated and can be run repeatedly, giving even more time back. Ultimately, the result will be a software product of much higher quality than previously, so there are fewer issues and bugs to resolve, and clients will be happier with the results.

Shifting testing leftwards is an important step in when mapping out a software development project. It ensures regular, early assessments that reduce the risk of critical bugs later, preventing damaging delays. Working with an experienced DevOps consultancy like Catapult can help businesses implement an automated, effective testing regime, and keep their projects on track.

Discover how Catapult can help coach your teams and embed good practice by visiting its website.