Draw a project timeline from left to right: requirements, design, coding, testing, release. In a traditional plan, testing sits towards the right, after most of the work is done. “Shift left” means moving quality activities towards the start of that line. The phrase is usually credited to Larry Smith, who wrote about shift-left testing in Dr. Dobb’s Journal in 2001, and it has since become one of the most quoted and most misunderstood ideas in the field. The easiest way to understand it is to look at what it is not.
Myth: shift-left means testers join the project earlier
Reality: putting a tester in requirement meetings helps only if the tester changes something there. A tester who attends a refinement session and silently starts writing test cases for the story as written has moved their calendar left, not the feedback.
The valuable contribution early on is asking the questions that would otherwise surface as defects weeks later. For a story like “allow customers to update their registered mobile number”, that means asking: is OTP sent to the old number, the new one, or both? What if the new number already belongs to another customer? Is the change blocked for some hours after a password reset, as many banks do to limit fraud? Can a customer do this from a new device? Each unanswered question is a future bug, a future argument, or both. Answering it in a 30-minute conversation costs far less than finding it in system testing.
Myth: the main tool is earlier test execution
Reality: much of shift-left is static, meaning it finds problems without running the software at all. ISTQB distinguishes static testing (reviews and static analysis) from dynamic testing (executing code), and the static side does most of the work at the left end of the timeline.
- Requirement and design reviews catch ambiguity, contradictions and missing rules.
- Acceptance criteria and examples written before coding, often in a “three amigos” conversation between product, development and testing, turn vague stories into checkable statements.
- Static analysis and linters in the developer’s editor and in CI flag null-pointer risks, injection-prone patterns and dead code within seconds.
- Code review with testability in mind catches logic that will be hard to verify later.
Dynamic testing does move left too, mainly through developers writing unit and API tests alongside the code and running them on every commit. The common thread is shorter feedback loops: the gap between making a mistake and learning about it shrinks from weeks to minutes.
Myth: a bug found early is always 100 times cheaper
Reality: the direction of this claim is sound, but the precise multipliers often quoted on slides rest on old and thin evidence. Laurent Bossavit’s book The Leprechauns of Software Engineering traces how figures like “100 times more expensive in production” were repeated far beyond the data behind them. It is safer to explain the cost difference by mechanism than by a magic number.
The mechanisms are real. A misunderstanding caught in refinement costs one conversation. The same misunderstanding caught in system testing costs a defect report, triage, a developer switching back to code written weeks ago, a fix that may touch other features built on the wrong assumption, a new build, and retesting. Caught in production, it may add customer impact, support calls, data correction and, in regulated sectors such as banking, a report to a regulator. The later the discovery, the more work has been built on top of the mistake.
Myth: shift-left makes later testing unnecessary
Reality: some problems only appear when the whole system runs under real conditions: performance under festive-season load, behaviour on low-end devices over patchy mobile networks, integration with a partner bank’s actual sandbox, real user confusion. These need testing later in the lifecycle, and some need observation in production itself.
That production-side work is sometimes called shift-right: monitoring, canary releases to a small share of users, feature flags, and analysing real usage to feed back into testing. The two are complementary. Shift-left reduces the number of defects that reach late stages; shift-right reduces the damage from the ones that still get through.
Myth: it is a testing team initiative
Reality: shift-left changes how the whole team works, and it fails when only testers are asked to do it. If developers are measured on story points delivered and testers on defects found, nobody is rewarded for preventing defects. Practical prerequisites include:
- Time in the sprint for refinement and example-writing, not just coding.
- A pipeline that runs fast tests on every change, so early feedback actually arrives early.
- Environments or mocks that let developers test integrations locally instead of waiting for a shared QA environment.
- Product owners who are available to answer questions during the sprint, not just at its start.
In outsourced setups common in India, where requirements come from a client in another time zone, the biggest shift-left gain is often simply getting questions answered before the build starts, perhaps through a fixed overlap hour with the client’s product owner each day.
How to tell whether it is working
Useful signals look at where problems are found, not just how many. If shift-left is working, you would expect more issues raised as questions during refinement, fewer defects whose root cause is “requirement misunderstood”, fewer defects found in late system or acceptance testing relative to earlier stages, and shorter time from commit to first test feedback. If the defect curve looks exactly as it did before, the team has probably moved meetings rather than feedback.
Written by the RP Strativa Team. The mobile-number change scenario is illustrative.
Leave a Reply