Move Fast and Build Things: A Modern Strategy for Innovation

The tech world loves its mantras, and "move fast and break things" is one of the most enduring. Born from an era of rapid growth and experimentation, it encouraged pushing boundaries, particularly within safe development environments where failure was a learning opportunity. However, as this phrase permeated broader tech culture, its interpretation often shifted. It sometimes became a retroactive justification for impacting production systems, disrupting established workflows, or prioritizing raw speed over stability and thoughtful design.

While the spirit of rapid iteration remains vital, high-performing technology organizations are increasingly embracing a more nuanced and sustainable strategy: Move fast and build things. This isn't just semantics; it represents a fundamental shift in how we approach adding functionality and evolving complex systems. It’s about achieving velocity without undermining the foundations we rely on.

The Core Tension: Modifying vs. Building

When faced with the need to introduce significant new capabilities into an existing software ecosystem, teams often face a crucial decision:

Option A: Modify the Existing System. This involves diving into the current codebase, altering existing logic, and integrating the new functionality directly within the established structures. It often feels like the most direct path.
Option B: Build a New Component. This involves creating a distinct service, module, or feature set, often using modern tools and architectures, and then integrating it with the existing system at well-defined points.

While modification might seem straightforward initially, experience often shows it's fraught with challenges:

Changing existing, complex systems is frequently the slowest, riskiest path. Why? Legacy codebases are often tangled webs of hidden dependencies accumulated over years. Understanding the full impact of a change requires deep dives and extensive regression testing, which itself is time-consuming and imperfect. Teams grapple with outdated technology stacks ill-suited for modern problems (technology mismatch), requiring awkward shoehorning of new tools. The inherent risk can breed a "fear factor," leading to overly cautious approaches and further delays.
Building new, distinct components and integrating them smartly is usually the fastest, safest approach (and often more cost-effective). This allows teams to work in a cleaner environment, leverage modern tooling optimally, limit the scope of testing, and contain the potential impact of issues.

An Analogy: Upgrading Your Car's Navigation

Let's illustrate this with a real-world example. Imagine you want modern navigation with real-time traffic and voice commands in your slightly older car:

The "Modify" Approach: You could replace the factory car stereo with an expensive ($500-$1500+) all-in-one aftermarket head unit that includes navigation. This typically requires complex installation – removing dashboard elements, potentially needing special wiring harnesses or adapters ("car surgery!"). Furthermore, the maps often need costly, manual updates (via SD card or dealer), and the unit's features are essentially frozen until you perform another expensive replacement. Integration with steering wheel controls might also require extra effort and adapters.
The "Build" Approach: Alternatively, you could keep the existing factory radio, spend $50 on a premium phone mount, and use your smartphone. This leverages a powerful computing device you likely already own. Integration is simple (place phone in mount, connect audio via Bluetooth/aux). You benefit from constantly updated apps (Waze, Google Maps, Apple Maps) with real-time traffic, voice commands, and a continuous stream of new features delivered via app updates. The cost is minimal, and there's zero risk to the car's core electrical systems or functionality.

The second approach doesn't perform surgery on the car; it builds upon the existing platform by integrating a modern, independent system (the phone) seamlessly into the user's experience.

Applying the "Build" Philosophy in Software

This "Build" approach translates directly to software development. Instead of performing risky "surgery" on a monolithic legacy application to add, say, a new recommendation engine, a team could:

Build a dedicated recommendation microservice using modern machine learning libraries and cloud infrastructure.
Define a clear API contract for how this service provides recommendations.
Call this API from the existing front-end application or relevant backend service.

The result? The new functionality is delivered faster, uses the best tools for the job, and doesn't destabilize the core application. The integration point (the API call) is far less complex and risky than modifying deep-seated legacy code. This allows for a seamlessly integrated experience for the end-user, even if the underlying technology components are distinct.

Key Benefits of Building Fast (and Smartly)

Adopting a "build-first" mindset when adding significant new capabilities yields substantial advantages:

✅ Speed & Agility: Development teams can leverage modern tools, frameworks, and languages without being constrained by legacy tech stack limitations. This accelerates development cycles for new features.

✅ Safety & Risk Isolation: When new functionality resides in a separate component, failures are typically contained. A bug in the new recommendation service won't bring down the entire e-commerce platform's checkout process. This dramatically lowers the risk of innovation.

✅ Modern Technology Adoption: Building new components provides natural opportunities to use best-of-breed technologies, improving performance, scalability, security, and developer satisfaction. It also helps attract talent eager to work with current tools.

✅ Easier Testing & Deployment: Testing is focused on the new component and its integration points. Techniques like feature flags, canary releases, and A/B testing become much safer and easier to implement, allowing for controlled rollouts and validation in production.

✅ Strategic, Gradual Modernization: Building new components alongside legacy systems enables a practical modernization strategy (often related to the "Strangler Fig" pattern). Over time, functionality can be incrementally moved from the old system to new services, allowing for gradual, validated replacement without the immense risk of a "big bang" rewrite.

Conclusion: Build Your Way Forward

"Move fast and break things" captured a moment in time, but for sustainable, high-velocity development in today's complex technology landscape, "Move fast and build things" offers a more resilient and strategic path. It encourages leveraging modern tools, isolating risk, and enabling gradual evolution.

Instead of constantly risking our foundational systems by trying to force change upon them, let's focus on strategically building the capabilities needed for the future, delivering value faster, more safely, and more reliably. It’s time to build our way forward.