Move fast and break things: accelerating testing with Upsun

When Mark Zuckerberg famously said, “Move fast and break things. Unless you are breaking stuff, you are not moving fast enough,” he was setting the stage for a bold approach to innovation. While his words have sparked debates, they resonate deeply when applied to software testing—especially when it comes to leveraging Upsun.

Testing with Upsun isn’t just about catching bugs; it’s about doing it quickly, efficiently, and without derailing your workflow. Let’s explore why breaking things fast is the key to accelerating testing and how Upsun makes it a reality.

Testing is expensive… or is it?

Here’s a stat to chew on: it’s 30 times more expensive to fix a bug in production than if you catch it earlier. I know, it sounds made up, right? It’s not. Think about it—a bug in production doesn’t just waste engineering time; it damages your brand, erodes customer trust, and pulls your team away from building new features. That’s why testing isn’t optional; it’s critical.

But let’s be real: testing can also feel like a bottleneck. Developers want to build cool stuff, not spend their days writing tests. How do you balance speed with safety? By embracing a philosophy I like to call breaking things fast.

The reality is that while most teams understand the need for testing, they often lack the tools to make it seamless. Without the right support, even the most well-intentioned efforts can falter, creating a cycle of frustration and delays. That’s where Upsun comes into play, transforming the testing experience from a hurdle into a catalyst for progress.

Breaking things fast: a different philosophy

Breaking things fast isn’t about chaos; it’s about intentional, rapid iteration. It’s about answering two fundamental questions:

1. Is it broken? (Unit tests, functional tests, exploratory tests, etc.)
2. When will it break? (Load tests, penetration tests, scalability tests.)

The goal isn’t perfection on the first try; it’s getting feedback as quickly as possible so you can fix issues before they snowball. Testing, in this sense, becomes less about process and more about curiosity—the desire to see how far you can push something before it breaks.

When you think about it, the essence of testing lies in embracing uncertainty. It’s not about proving that your code works; it’s about uncovering how and where it doesn’t. By shifting the focus to breaking things fast, teams can foster a mindset of exploration and improvement, one that drives innovation rather than stifling it.

The problem with traditional testing

Let me take you back to 2002. I was a self-proclaimed "webmaster" (yes, that was a real title) at Eastern New Mexico University. My testing process? FTP the HTML files directly to the server, hit refresh, and see if it worked. If it didn’t, I’d tweak the code, FTP it again, and repeat. It was crude, but it worked… most of the time.

Fast forward to today. We’ve traded FTP uploads for staging environments, dev environments, and CI/CD pipelines. These are all good things—but they come with a major limitation: they rarely match production completely. Spinning up a staging environment might only take hours or days, but replicating production’s full complexity is another story. Infrastructure, networking, caching, search, data, dependencies, runtimes, and frameworks all play critical roles in how an application runs—and none of these are strictly tied to your code. Failing to copy these variables faithfully creates gaps that make your tests unreliable and your bugs harder to catch. By the time you’ve fixed a bug, your users have already encountered it. That’s not moving fast; that’s stumbling in the dark.

Consider the complexity involved: configurations, data syncing, permissions, and compatibility checks. Each step adds friction, making it harder to deliver on time. For teams working under tight deadlines, this can feel like running a marathon in quicksand. It’s no wonder developers yearn for a faster way.

Testing in Production: A Love-Hate Relationship

But what if we could test in production? It’s a provocative idea, and for good reason. Testing in production gives you the most accurate data possible. There’s no worrying about whether your staging or dev environment perfectly mirrors production—it’s the real thing. Every infrastructure detail, networking configuration, caching layer, and runtime is exactly as it should be.  You would be able to get immediate feedback, test performance, and understand environment-specific issues.

But there is one problem with testing in production… users.  The “break things fast” mentality only works if users aren’t involved.  The end goal is for users to have an amazing experience.  That’s far from possible if you are breaking the app for them every time they go to use it.  

So, what’s the alternative? Replicating production—and this is where Upsun shines.

Upsun’s Secret Sauce: Full-Stack Cloned Environments Ecosystems

What if you could clone your entire production environment—code, data, infrastructure, services—in seconds? With Upsun, you can. Here’s how it works:

1. Branch from Git: Every cloned environment starts with your Git branch. But it’s not just the code that gets cloned; it’s the entire stack.
2. Perfect Replication: Upsun doesn’t just copy your code; it mirrors your databases, APIs, services, DNS settings, SSL certificates… everything.
3. No Users, No Risk: The one thing we don’t clone? Users. That means you can break things to your heart’s content without fear of angry tweets or support tickets.

With Upsun, you get the speed of testing in production without the risk.

This ability to replicate production environments has profound implications for development workflows. By eliminating the barriers between testing and deployment, Upsun empowers teams to iterate faster, deploy more confidently, and innovate without hesitation.

Real Stories, Real Impact

Let me share a quick story from SymfonyCon. During a live demo, my colleagues turned a monolithic app into a decoupled app (Next.js frontend with a Symfony backend) all within 30 minutes. How did they do it?  By breaking things fast.  Like any live demo, they had their code all lined up and perfectly running before the event.  But like any live demo, everything fell apart right in the middle of the demo.  Every time they tried to deploy the app, they came up with a different error.  In the span of 30 minutes they tried iteration after iteration after iteration in front of a live audience.  The culprit? A single-character in a YAML file. (Turns out “npm” isn’t the same as “npx.” Who knew?)

Now, imagine trying to do that in a traditional setup. One developer told me it used to take them three weeks to spin up a dev environment. By the time they got everything configured, the data was already out of date. With Upsun, those three weeks become three minutes.

The Upsun Workflow: Iterate, Iterate, Iterate

Here’s what a typical workflow looks like with Upsun:

1. Create a branch and instantly clone production.
2. Make your changes—whether it’s tweaking code, updating APIs, or testing new database configurations.
3. Iterate until it works.
4. Merge your branch and promote the environment to production.

It’s fast, it’s seamless, and it’s developer-friendly. No more waiting for Ops. No more guessing if your changes will break in production. You’re free to innovate at the speed of thought.

The beauty of this approach lies in its simplicity. By removing the friction from testing, Upsun enables developers to focus on what they do best: creating solutions that drive value for their users. It’s a game-changer for teams looking to stay competitive in an increasingly fast-paced world.

Why Breaking Things Fast Matters

At the end of the day, breaking things fast isn’t just about efficiency; it’s about creating a culture where developers can experiment, fail, and learn without fear. Testing should empower you to build better software, not slow you down. With Upsun, you’re not just testing faster; you’re building a better future—one broken thing at a time.

Imagine a world where testing isn’t a burden but a source of inspiration, where teams work collaboratively to push boundaries and uncover possibilities. That’s the world Upsun is helping to create, and it starts with you.

In fact, studies show that identifying and resolving bugs earlier in the development cycle can increase customer satisfaction by up to 40%. Fewer bugs mean smoother user experiences, higher retention rates, and glowing reviews. By prioritizing efficient testing, you’re not just building better software; you’re building stronger relationships with your users.

Ready to move fast and break things? Let’s get started.

Watch this video