Here’s a bold statement: traditional testing strategies might be holding your team back from delivering high-quality software at speed. But what if there’s a better way? Ola Hast and Asgaut Mjølne Söderbom, in their QCon London talk, reveal how their team has revolutionized their approach to software delivery by leaning heavily on Test-Driven Development (TDD), pair programming, and testing in production—yes, you read that right. And this is the part most people miss: they’ve completely ditched end-to-end tests in favor of robust unit and integration tests, paired with feature toggles to minimize risk. But here’s where it gets controversial: they argue that production environments provide the most reliable feedback, rendering traditional test environments nearly obsolete. Let’s dive into why this approach works—and why it might just challenge everything you thought you knew about testing.
Hast and Mjølne Söderbom emphasize that their trust in unit and integration tests isn’t blind; it’s built on a foundation of solid design principles like separation of concerns, modularity, abstraction, low coupling, and high cohesion. These principles, combined with TDD and pair programming, result in a domain-driven design that delivers high code quality. But here’s the kicker: they’ve moved away from HTTP application integration tests that cover the entire app, opting instead for focused tests with shorter feedback loops. Why? Because, as Mjölne Söderbom explains, test environments are inherently flawed—they’re approximations of production, often plagued by long supply chains and poor test data. So, why settle for second best when you can test where it matters most?
Their strategy is simple yet radical: deploy small changes frequently, use feature toggles to control exposure, and test in production for real-world feedback. If something goes wrong, it’s easy to identify, fix, and roll back or forward. This approach isn’t just theoretical—they’ve been practicing it for years with remarkable success. But here’s the question: could your team adopt this method, or is it too risky? Let’s explore further.
In a previous article, Hast and Mjølne Söderbom highlighted their use of pair and mob programming alongside TDD, eliminating solo tasks and separate code reviews. This collaborative approach not only boosts code quality but also fosters knowledge sharing and reduces waste. And this is the part most people miss: their shift away from local or test environment testing wasn’t a deliberate goal—it was a natural consequence of their streamlined workflow. Pair programming, they argue, complements continuous integration perfectly. Pushing to main multiple times a day becomes feasible because pairing enables instant code review, seamless refactoring, and fewer bugs. But is this approach scalable for larger teams? That’s a debate worth having.
Hast points out that their testing strategy has evolved significantly. They’ve minimized tests that run the entire application, retaining only a happy path test and additional tests for specific error scenarios. Here’s the controversial part: they prefer testing in production for anything unit tests can’t cover. Why? Because production feedback is the most accurate, and test environments often fall short. But does this mean traditional testing is dead? Not necessarily—it’s about finding the right balance.
The core of their philosophy is fast feedback loops. As Mjölne Söderbom puts it, feedback is the compass that guides their direction and helps them pivot when needed. Their tests provide speed, while production provides depth. And this is where it gets interesting: they intentionally increase the frequency of deployments to production, even if it’s painful, because that’s where they uncover and fix issues fastest. This process has been their North Star for over a decade.
TDD, in their view, isn’t just a testing tool—it’s a design tool. If code is hard to test, it’s a sign of poor design. But here’s the thought-provoking question: are we using TDD to its full potential, or are we stuck in the mindset that it’s only about writing tests? Mjölne Söderbom argues that the real value of TDD lies in driving better design, with fast feedback being a welcome side effect.
So, here’s the final question for you: Could your team benefit from this radical approach to testing and deployment? Or do you think the risks outweigh the rewards? Let’s start the conversation in the comments—I’m eager to hear your thoughts!
