How often do we hold back because we're afraid to get it wrong? What breakthroughs are we missing out on because of this fear?
The mantra of "fail fast, fail cheap" has become synonymous with innovation. But what does it truly mean for us, and how can we apply it effectively?
Redefining Failure
Greg McKeown’s book Effortless shares the story of Paul MacCready, an aerospace engineer who redefined failure.
Faced with crushing financial pressure and a challenge that had stumped experts for decades—building a human-powered aircraft—MacCready decided to take a radically different approach. Traditionally, teams spent years perfecting designs before testing, making any failure costly and discouraging.
MacCready flipped the script. Using lightweight materials like wood and Mylar, he built prototypes so simple they could be repaired with a broom handle. This allowed him to test, fail, and iterate quickly.
Within months—rather than years—he achieved what many thought impossible. The Gossamer Condor won the Kremer Prize for sustained, controlled, human-powered flight. He didn’t stop there. His Gossamer Albatross crossed the English Channel, proving that rapid iteration and simple, efficient design could solve real engineering challenges.
His success proved the power of making failure fast and cheap.
Applying the Philosophy
This mindset is a game-changer in software development. In a rapidly evolving field, slow learning is costly. The more teams iterate, the quicker they find flaws, refine solutions, and build better products.
As we build the first product on our strategic platform, we must embrace MacCready’s mindset. Uncertainty is inevitable, but agility and experimentation turn it into an advantage.
By fostering a culture of quick, cost-effective iteration, we empower our teams to learn fast and innovate smarter.
The Creativity Loop
Innovation doesn’t happen by getting everything right the first time. It comes from testing, learning, and refining. This loop guides our progress.
Here’s a simple approach to fast iteration:
- Define – Describe the problem clearly.
- Design – Create a simple, flexible solution.
- Build – Develop a minimal, working version.
- Get Feedback – Learn from real usage.
- Iterate – Improve based on data.
This loop mirrors MacCready's method. Each cycle is an opportunity to learn and improve, bringing us closer to the optimal solution without unnecessary delays.
Speed Matters: Fast Feedback, Better Results
The faster we get a product or feature into users' hands, the sooner we find out what's working and what isn't. Instead of spending months perfecting something only to discover it doesn't meet users' needs, we release early, gather feedback, and adjust. This approach saves time and helps us build something that truly resonates.
For example, the Unified Platform went live with just one API, which allowed us to gather crucial user feedback that shaped subsequent development.
Breaking development into small, functional blocks enables us to build quickly and deliver incrementally.
Simplicity Wins
Simplicity beats perfection. It's a core value that guides our work.
- Simplicity = Clarity: Simple solutions are easier to understand, communicate, and implement. They keep everyone aligned.
- Fast to Deliver and Easy to Maintain: Simplicity accelerates development, makes maintenance easier, and allows us to adapt quickly as needs evolve.
- Simplicity Doesn’t Mean Missing the Big Picture: It's about distilling solutions to their essence without losing sight of overarching goals.
Over-engineered software tries to solve every possible problem upfront. The result? More complexity, more cost, less agility.
Prioritising simplicity keeps us moving forward.
Data-Driven Decisions
Minimising the cost of failure requires informed, data-driven decisions. Without measurable data, choices are based on assumptions, increasing risk.
Consider web performance. Jakob Nielse's research suggests that a 0.1-second response time feels instant to users. But modern expectations have evolved—anything beyond 2 seconds significantly impacts engagement. By setting clear performance goals, teams can ensure a better user experience and avoid guesswork.
Without benchmarks? Then, start with a simple version. Real-world usage reveals what truly matters.
For example, when developing a new data streaming architecture, it’s tempting to optimise too soon. Many teams over-engineer before real-world needs justify it. But by launching a simple, adaptable version first, we collect real data. This ensures future refinements address actual performance constraints, not hypothetical ones.
We can’t improve what we don’t measure.
Embracing Reuse
Another way to fail cheaply is to reuse. Proven solutions save time and reduce risk.
Instead of reinventing the wheel, we can build on tested frameworks, libraries, and architectures. This speeds up development, minimises technical debt, and lets us focus on what matters: adding unique value.
The Takeaway
Failure isn’t a setback—it’s a tool for progress. Inefficiency manifests as long cycles, overengineered solutions, and slow feedback. This slows down innovation and creates unnecessary complexity.
By focusing on rapid iteration, data-driven decisions, simplicity, and reuse, we minimise inefficiencies and turn failure into learning.
Mistakes don’t stop progress—fear of them does.
