Tester-driven development
The developer finishes the export and moves the ticket to QA.
The tester selects a date range with no results. The export fails. The ticket returns to development, a condition is added, and the next version produces an empty file. The tester then tries a large result set. The request times out. Another fix follows. A third pass reveals that a user with restricted access can export records they cannot see on the screen.
Each finding receives a fix. Each fix produces another version to test.
By the end of the week, the export has acquired several new branches, the tester has learned how it behaves, and the release is waiting for another pass through QA. The developer has already started the next ticket.
This is tester-driven development: a process in which QA findings become the instructions for completing the implementation.
In test-driven development, an executable expectation guides a change and remains available to check it again. Here, the next instruction arrives through a person testing an implementation that has already been handed over. Progress depends on the next finding, the next patch, and the next opportunity to verify it.
Separate development and QA roles can support careful work. A tester brings a different perspective, explores unexpected behavior, and questions assumptions the author has stopped seeing. The pattern takes hold when that perspective becomes the routine means of establishing whether the implementation handles its basic responsibilities.
The handoff then carries a division of responsibility.
Development produces something for QA to examine. QA discovers what remains to be done. The developer fixes the reported cases. The tester decides whether those fixes have made the feature ready. A ticket can travel through this loop several times while each person follows the process exactly as expected.
Sometimes the requirements were incomplete from the start.
The ticket says that users can export reports. Nobody has decided what an empty export should contain, how large an export can be, or which permissions apply to the underlying records. Implementation gives those questions a concrete form. QA encounters them while testing and starts conversations that should now involve product, development, and whoever understands the access model.
The team is discovering the feature after building its first version.
Other times, the requirements were clear. Access rules were written down. The expected behavior for empty results was already agreed. The developer implemented the ordinary path, tried it once, and handed over the rest of the verification because testing belongs to QA.
Both situations can produce the same ticket history: ready for QA, returned to development, fixed, ready for QA again. Understanding the cause is the differentiator. One team needs earlier decisions. Another needs developers to take responsibility for checking known expectations. Many need both.
The repeated loop starts shaping the code.
A bug report describes an observable case. A user with one role receives the wrong result. A particular sequence leaves the screen in the wrong state. A certain input causes a failure. Under delivery pressure, the quickest response is often a condition that handles that case.
The condition may be correct locally while preserving the assumption that caused the defect.
In the export, access might be checked in the screen while the export query reads directly from storage. Adding a filter for the role mentioned in the bug report can make that example pass. It also leaves two places defining who can see which records. The next permission change now has to reach both places, and the next tester may discover where they disagree.
A stronger repair would examine how access is enforced across the feature and give both paths a dependable rule to use. That requires understanding, design judgment, and verification beyond the single reported case.
The process often makes the smaller patch easier to finish.
The ticket has an expected result. The developer can demonstrate that result after the change. QA can retest it. A broader repair touches more code and raises more questions about what needs checking. With a release approaching and a queue already forming, the local fix has a clear route through the system.
Repeat that choice across enough tickets and the implementation becomes a record of discovered exceptions. Similar conditions appear in several places. State transitions acquire special handling. A rule that could have been expressed once becomes scattered across the paths where somebody happened to find a failure.
Individual fixes can look reasonable while the structure becomes harder to understand.
Knowledge fragments along the same route.
The tester learns which combinations fail. The developer learns enough about each report to repair it. Product answers questions in ticket comments or messages. Someone explains an old exception during a call. Each exchange moves the current case forward, but the complete explanation remains spread across people and artifacts.
The ticket may close with a better implementation and several facts that never become shared understanding.
Later, another developer changes the export. They read the original requirement and the current code. The reason for one condition lives in a closed defect. The reason for another lives in the tester's memory. A third came from a conversation with a stakeholder who has since moved to another project.
The team discovers the feature again.
Discovery is a normal part of software development. The accumulating cost comes from repeatedly learning the same behavior without giving that learning a durable home. Some of it belongs in acceptance examples, some in automated tests, and some in a clearer design. A complicated product rule may also need a short explanation of why it exists.
Without those forms of memory, QA becomes the place where the system's behavior is reconstructed for each change.
This affects what “finished” means.
A developer can complete the implementation on Tuesday while the team has little basis for predicting when it will be releasable. QA may find one small defect or uncover a mistaken model that requires substantial rework. A fix can invalidate an earlier check. Another ticket can interrupt testing. The calendar contains a development estimate followed by a discovery cycle of uncertain length.
Work keeps entering that cycle while older work returns from it.
Developers switch between new features and fixes from previous handoffs. Testers switch between new implementations, retesting reported defects, and checking nearby behavior for regressions. A small change can wait days for a short verification because the people capable of doing it are already committed elsewhere.
The queue starts determining the release rhythm.
Manual testing takes attention and time. Where routine correctness depends heavily on it, release capacity becomes tied to the availability of the people performing those checks. Adding development capacity can send more work into the same queue. Shortening the sprint can bring the next deadline closer without shortening the verification already waiting.
QA is visible at the point where the release waits, so the delay is easily described as slow testing. Much of the demand was created earlier: incomplete implementation, unsettled behavior, repeated local fixes, and checks that must be performed again by hand.
The same dependency gradually closes the door on refactoring.
Every code change requires QA. That rule can sound reassuring in a fragile system. A small change has caused unexpected failures before, and the team wants someone to check that existing behavior survives.
The rule also gives every improvement a testing cost.
A developer wants to consolidate the export's access checks. The change preserves the intended behavior, but it touches several paths. QA needs time to exercise the relevant roles, report types, and result sizes. That time competes with promised features and defects already affecting users.
The feature has a customer waiting. The defect has a reproducible failure. The refactor offers code that will be easier to understand and safer to change later. In a queue organized around immediate product outcomes, the refactor is easy to defer.
Eventually, developers stop proposing it.
They know that even a modest structural improvement needs a place in the QA schedule. They leave the duplication, add another condition, and keep the diff close to the reported bug. A capable engineer who sees the underlying problem can still be constrained to a patch by the available route to release.
The team has made code quality dependent on spare testing capacity.
That capacity becomes harder to find as the code deteriorates. More exceptions make changes difficult to reason about. Uncertain changes require broader manual checks. Broader checks consume the time that could have supported structural improvement. Refactoring becomes increasingly expensive just as the need for it grows.
Fragile code creates demand for verification, and the cost of verification helps preserve the fragility.
Managers can look for this pattern in the movement and content of the work.
Read several tickets that returned from QA. Were the findings about agreed behavior the developer could have checked? Did testing expose unresolved product decisions? Did each fix address a common cause or add another exception? Ask where the resulting knowledge can now be found.
Then look at the maintenance that never starts. Which improvements have been deferred because QA is busy? Which small repairs became acceptable only after a user-visible defect appeared? What does a developer have to arrange before changing code purely to make it clearer or easier to maintain?
These questions reveal more than a count of defects by author. A low count can reflect simple work or limited testing. A high count can reflect valuable exploration of a difficult area. The useful evidence connects a finding to the expectation, the implementation decision, and the verification available before handoff.
Changing the pattern starts before the next ticket reaches QA.
For the export, development, QA, and product can examine a few concrete examples together: no results, a large result set, a restricted user, and a failed request. The conversation gives the developer a model to implement and lets the tester influence the work while assumptions are still inexpensive to change.
The developer then needs to verify the behavior they are handing over. That includes exercising the feature, checking the agreed cases, and adding automated coverage where it provides useful repeatable evidence. The handoff should explain what was checked and where uncertainty remains.
QA can use that evidence to choose further exploration. Testing can concentrate on interactions, unexpected sequences, usability, and risks that benefit from an independent perspective. Findings still arrive. The team now has a stronger foundation from which to interpret them.
When a finding exposes a faulty assumption, review the repair at that level. If access is enforced inconsistently, discuss the rule and its callers. If state can become invalid, examine how transitions are represented. A regression test should preserve the lesson, and the implementation should express the behavior clearly enough for the next person to understand it.
Automation needs deliberate investment. A long manual checklist takes time to turn into dependable checks, and some exploratory judgment will remain with people. Start with stable, repeated checks that consume attention every release or with defects whose recurrence would be costly. Place checks where they can give useful feedback quickly and remain practical to maintain.
Maintenance also needs an explicit route through planning and verification.
Reserve capacity for bounded improvements. Agree on what behavior must remain stable, what evidence will establish that, and where manual examination adds value. A local refactor with good automated coverage may need a different verification effort from a change to a shared access rule. The people responsible for quality should make that distinction together.
As the evidence improves, the team can make smaller changes with more confidence and less repeated manual work. That creates room for the next improvement. Restoring this room is part of delivery: it determines how much future work the team can carry safely.
Back at the export, the empty-result case becomes an agreed example with an automated check. The access rule moves into a shared policy used by both the screen and the export. The team decides how large exports should behave before another timeout becomes a ticket. QA explores combinations around those decisions and records what the exploration reveals.
The developer remains responsible for the feature through that learning. The tester's findings inform a shared understanding that survives the release.
A healthier team can explain why a change works, preserve the evidence, and improve the code without waiting for another defect to make the work permissible. Quality grows through the decisions made while building, reviewing, testing, and maintaining the feature. Each role contributes to that responsibility, and the code carries more of the team's understanding forward.