In the ideal world of software development, releases should be moments of celebration. It’s the time when our hard work finally becomes a reality, delivered to the users. Yet, instead of joyous milestones, releases often become our greatest source of stress. We plan ceremonies around these releases, but the anxiety often overshadows any sense of accomplishment.
So, why does hearing that some projects have multiple releases a day overwhelm us with anxiety, and why do we hesitate to try adopting this approach ourselves? Why do we still run away so much from continuous delivery and from truly standing behind our work?
In the end, it all comes down to the question of quality. We can believe that the work delivered is an amazing idea, but somehow it is very hard for us to be quite certain that it works as expected. This fear comes with concern about the ability to maintain quality at such a fast pace, as well.
But with the right practices in place: coverage through different levels of testing, continuous integration, and a strong culture of collaboration, this fear can be manageable. Then, frequent releases can become not just possible, but a powerful tool for delivering value to users faster.
In software development, quality is not just the responsibility of a selected few; it’s a collective responsibility that everyone involved in the process must share. It doesn’t start with development, but already from the early stages of design. Indeed, quality goes beyond just testing; it's about quality development, clear communication, and setting the right expectations from the start.
However, when we talk specifically about testing, it is often perceived as a quality activity done in layers. Each layer plays a critical role in ensuring that the software is ready. By applying the following levels of testing, we can ensure that the application/software is covered at various levels.
Unit tests are our early warning systems, catching issues at the smallest scale. The goal is to have a limited scope and ensure that isolated code units function as expected. They are under the ownership of the development team.
Component testing involves evaluating test objects independently as components, without integrating them with other components. The goal is to test individual modules and pages in detail. Component tests are the responsibility of the development team, but they include collaboration with the QA team.
Smoke tests validate that the most crucial parts of the application are up and running, making sure the environment is stable and accessible.
The purpose of End-To-End (E2E) tests is to simulate real user scenarios by validating the complete flow of the application from start to finish.
Manual exploratory tests provide the final review by focusing on edge cases and identifying potential issues that other testing levels might miss.
It is clear that different types of tests, listed above, have different ownership. However, if we want to have them as effective as possible it is important to avoid repetitiveness in what we are testing. Both developers and QA have the opportunity to share their input and agree on the scope of their tests. This practice can easily become a part of your routine during the planning or even design phase.
Yes, ensuring quality throughout development and delivery is a shared responsibility between developers and QA teams, each contributing through various levels of testing. That is why we should use this to our advantage and not keep each type of test in Sylos.
While developers are crucial in establishing and maintaining quality from the start, fostering a quality culture is collaborative. This teamwork helps prevent small issues from escalating into more complex problems and promotes a high-quality standard across the organization.
This way we can set the path for some quality practices that can be applied as early as the design phase: challenging design, discussing edge cases, and keeping the focus on value.
To reach the goal of a high-performing delivery with consistent quality, it’s clear that quality must be a collective responsibility. Effective quality assurance requires ongoing collaboration within the organization, ensuring frequent deliveries are smooth and stress-free. This doesn’t just involve levels of testing but covers every aspect of development, communication, and expectations.
By maintaining this quality culture, we can turn releases back into the celebrations they were always meant to be.