Skip to content
Related Articles

Related Articles

Improve Article

Shift Left Testing approach

  • Last Updated : 06 Apr, 2020

Software testing is a necessity. It ensures that a product is being released to end customers without faults. And being a widely discussed topic, there are many approaches to testing software.

Some companies champion a “waterfall approach” to product design. Here, the software is designed sequentially. It strictly goes through the development cycle of:

1. Requirements/Gathering
2. Design
3. Development
4. Deployment 

Testing is delegated to the end stages of the product design (before the deployment stage). This is normally called “shift right testing”.

Testing at the End Stages – An Inferior Strategy:
All codes are prone to bugs. And bugs can be minor (low risk) or major (high risk) depending on the type of error.

The earlier those bugs are caught, the better. It allows time for development teams to fix software without delays and avoid prolonged end testing phases. It’s also easier to fix bugged software when too many bugs aren’t showing up at the same time. This is the reason shift right strategies is ineffective in most cases.

Realistically, it’s exhausting going through every coding line of an end-product – just to find a bug or two. It’s better to fix each unit as the code is being developed. And this is where shift-left comes in!

  1. Improved Code Quality:
    The earlier you detect a bug, the better. It allows for better communication between testing and developing teams. It allows both teams to address each bug 1-by-1.

    Contrast that to a shift-right approach. Here, all bugs are addressed at once. And many may be forgotten or ignored (due to time or budget constraints).

  2. Multiple test types:
    When codes are tested at each design stage – a multitude of test types can be applied.

    For example, unit testing is a possibility with a shift-left approach. Here, each component is tested separately to check for individual bugs. Also, integration testing can be done frequently across the design stage. And this ensures that bugs don’t develop as different units are assigned together.

    Contrast that to shift-right strategies, which only allow for the possibility of system testing. And even that isn’t accurate and isn’t effective at discovering all bugs.

    Finding design defects and architectural problems:
    Sometimes, bugs aren’t the problem. Major aspects (or ideas) that are being implemented that may be defective. Those defects (which may interfere with other codes) should be discovered early. Otherwise, too much time is wasted on implementing major design plans that are unfeasible.

    This is another added pro of shift-left testing. After all, smaller unit tests are automated, and their test cases are easy to design.

    Contrast that to system testing – which takes time, and must be done manually. It also can’t be repeated often. And that repeatability is what makes shift-left approaches better. It allows for a product of better code quality, reducing the chances of high-risk errors!

  3. Reduced development and testing costs:
    Bugs that are caught early reduce the chances of side-effects.

    With fewer side-effects to worry about, product launches can be done on-time. A final code can be delivered to the end customer without needing future fixes. Here, it’s recommended that bug tests are done after every build. This allows for better automated continuous testing, which is impossible with large bug sizes.

    Also, shift-left approaches reduce the need for system testing. And in fact, that might be eliminated altogether if testing is done frequently.

    Fewer problems for future versions:
    Many software is designed with online features. They’re also designed with the intention of patching future versions. Those future versions cannot be added in – if prior versions have unfixed bugs.

    This leads to a “bow wave” effect, where multiple bug side-effects might stack. And the result is, certain bugs become impossible to fix.

  4. Keeps all project stakeholders informed:
    With the shift-left approach, testing is done at each critical stage of the software’s development. As a result, the testing team ends up (by necessity) being involved in the planning of the project. They’re also informed on its business goals.

    This lets them gain a better perspective on the software’s purpose. And it allows them to find creative ideas and solutions in the middle of testing. Plus, it keeps them motivated. Because testing teams understand what their efforts contribute to in the long-run.

  5. Keeps the developer team conscientious:
    Many design projects put developers in the position of creating code. But what about checking quality while writing each line?

    This mindset is ingrained into developers by encouraging frequent testing. And since testing requires time-consuming revisions, it ensures that a developer minimizes errors while writing code.

    With a shift-left approach, developers are encouraged to be more responsible. And it also enhances their skills and proficiency levels!

  6. Improved testing collaboration:
    Shift-left approaches take advantage of frequent “automation”. It lets them perform continuous testing to reduce time. But, that still leaves the problem of designing those tests. And this is often left to the testing team to figure out.

    Also, the problem here is, designing the best tests requires knowing the purpose of the product, and it’s business goals.

    With a shift-left approach, since developer and testing teams work together – they can design automated tests with each other’s’ input. This leads to the development of testing scenarios that are realistic and accurate at finding bugs and problems.

Picking the approach that works for you:
Shift-left approaches can be practiced in a multitude of ways. And they suit software of all sizes (from large online platforms – to small mobile apps). As a result, you’ll find that your design deadline differs based on the project. And as a result, the approach you pick differs.

  • Model-based:
    At least half of a given software’s bugs appear during the requirements gathering phase. Finding bugs in that stage reduces any need to fix bugs later on. Plus, they keep testing teams informed on the basic goals of the project.
  • Traditional testing:
    Here, the focus is on continuous testing, through unit and integration tests. It focuses on automation as much as possible, thus saving time and development costs.

    This form of testing tends to ignore acceptance and system tests (whose results are more or less guaranteed through frequent unit/integration tests).

  • Incremental testing:
    This tries to mimic a traditional testing model – but it’s aimed at large projects. Testing is broken down into minor pieces, where a set of codes are tested. After codes are integrated together, they’re tested again to ensure a lack of bugs.
  • DevOps/Fragile testing:
    Performed less frequently than traditional models, this form of testing works for smaller projects that have tight deadlines.

Attention reader! Don’t stop learning now. Get hold of all the important CS Theory concepts for SDE interviews with the CS Theory Course at a student-friendly price and become industry ready.


My Personal Notes arrow_drop_up
Recommended Articles
Page :