Shift left, ship fast: How software teams can offer speed without sacrificing quality (Brains Byte Back Podcast)

Erick Espinosa
Tue, 22 Jul 2025 16:51:17 +0000
Brains Byte Back

Even the biggest software companies understand that moving quickly is no longer a luxury; it’s a requirement to stay competitive. With technology advancing rapidly, the pressure to keep up is intensifying.

Whether it’s launching new AI features or recruiting the world’s most influential engineers from competitors, the businesses that react first tend to lead. That urgency also applies to how they build and deliver software, using shipping speed as a way to close the gap in AI adoption.?

This matters because users, both enterprise and consumer, will gravitate toward the products that evolve fastest. But the process is more nuanced than just shipping first. It’s those who can continuously test, refine, patch, and improve the product that lead. That in itself is the challenge, according to Arjun Iyer, Co-founder and CEO of Signadot, who joined us on our latest episode.

In today’s world, the ability to push reliable updates in real-time isn’t just a technical advantage; it’s a business one.

But if everyone knows speed matters, why are most teams still struggling to move fast?

The Bottleneck Isn’t Generating Code, It’s Validating It

According to Iyer, one of the challenges is that the volume of code generation has increased, but the testing environments to validate the code haven’t.?

Writing code is getting easier, especially with GenAI tools. But validating that code in limited production-like environments is stifling teams, says Iyer.

“You need to make sure it works functionally, performs well, scales, and meets security and compliance standards. That’s the bottleneck, and it’s only getting harder as the volume of generated code increases.”

Without isolated environments, test feedback slows to a crawl. That’s not a process problem, but rather an architectural one.

“Many teams don’t have enough on-demand environments, so developers queue for access, delaying testing and shipping. That’s a huge bottleneck in cloud-native teams.”

Quality Still Comes First

Pushing updates quickly might look impressive, but if those changes lead to bugs or downtime, the damage is real. Releasing broken features doesn’t just cause technical issues; it impacts how users see your product. And in competitive markets, trust is hard to earn and easy to lose.

“A buggy release damages trust and can lead to churn. Brand perception is everything. You need to ship fast, yes, but never at the expense of quality. And that’s the real tension,” adds Iyer.?

Teams can’t afford to chase rapid delivery without backing it up with the confidence that what they’re shipping will actually work. Otherwise, they’re just setting themselves up to lose users, revenue, and momentum.

The Shift-Left Mind-Set Is How You Stay Ahead

The earlier you find bugs, the easier they are to fix. That’s not a new idea, but in today’s development cycles, it matters more than ever. According to the Signadot CEO, it’s a crucial component for modern developers to avoid costly mistakes.

“If you catch a bug in production, it’s 100x more expensive to fix than if you’d caught it during development.”

Bugs that sneak through to production don t just take longer to resolve, they create costs across engineering, support, and customer experience. When testing happens earlier during design, code, or commit stages, then that feedback loops tighten, and teams avoid downstream problems.?

“Shift-Left helps you move faster and maintain quality. It’s a crucial mindset shift for modern teams.”

Teams that build testing into the earliest parts of their workflows aren’t just catching problems sooner. They’re building the kind of resilience that lets them ship with confidence continuously, adding value from start to finish.

You can listen to the full episode on Spotify, Anchor, Apple Podcasts, Breaker,, Google Podcasts, Stitcher, Overcast, Listen Notes, PodBean, and Radio Public.

Find out more about Arjun Lyer here.

Learn more about Signadot here.

Reach out to today’s host, Erick Espinosa – erick@sociable.co

Transcript:

Erick Espinosa:
Welcome to this episode. I’m your host, Erick Espinosa, and admittedly, I’ve never worked in software development. But one of the beautiful things about this podcast is that I get to connect with a lot of brilliant minds who do. And the one thing I’ve discovered—well, I’ve discovered a lot—but one of the big ones is that the pressure to produce and ship fast is very real.

In today’s world, where AI can generate entire codebases in literally minutes, that pressure is colliding with something else: complexity. Think about it—more code means more tools, which increases the risk and can actually slow down delivery. In fact, according to a recent report from GitHub, developers now spend more than half of their time not coding, but testing, validating, and just waiting for access to the right environment.

That’s where today’s guest comes in. I’m joined by Arjun Iyer, co-founder and CEO of Signadot, and someone who’s spent more than 20 years in the world of distributed systems and cloud-native software. He’s worked in some very cool places, including AppDynamics, but today he’s tackling one of the biggest problems in software delivery: How do you move fast and maintain quality?

We talk about the real-world bottlenecks slowing teams down, why AI isn’t a silver bullet—as Arjun shares, just generating code doesn’t make it production-ready—and how concepts like Shift-Left are giving teams smarter ways to build.

Arjun Iyer:
I’m Arjun Iyer, founder and CEO of Signadot. My role spans engineering, sales, and marketing—really making sure we’re solving real problems for customers in cloud-native development and testing. I focus on ensuring we attract the right customers and that we’re growing in a meaningful way.

Erick Espinosa:
Arjun, thank you for taking time out of your day to join us. You’re a seasoned vet in software development, and I’m interested in picking your brain on the evolving challenges, particularly in distributed cloud-native environments and how AI and agentic systems are reshaping that landscape.

I also want to touch on the relationship between software development and shipping. You recently wrote a piece in Entrepreneur titled “Shipping is Slow. Here’s How European Entrepreneurs Can Pick Up the Pace.” But before we dive into that and your company, can you tell us how you got into this field?

Arjun Iyer:
I’ve been in software development for over two decades. My background is in distributed systems, which I studied during my master’s program. Over the years, I’ve worked at both traditional and cloud-native software companies. For the last 10 years or so, I’ve been deeply focused on cloud-native development.

Every company wants to ship fast—that’s the competitive advantage. But there’s always this tension between innovation and compliance, or between shipping velocity and security. Striking a balance between shipping quickly while maintaining high quality, compliance, and security has always been a central challenge.

Erick Espinosa:
What are some of the key issues you noticed when it comes to bottlenecks in software delivery?

Arjun Iyer:
This really came to light during my time at AppDynamics, where we were building complex, distributed, microservices-based software. I came face-to-face with delivery friction—especially validating code changes.

Writing code is getting easier, especially with GenAI tools. But validating that code in a production-like environment is where the real challenge lies. You need to make sure it works functionally, performs well, scales, and meets security and compliance standards. That’s the bottleneck, and it’s only getting harder as the volume of generated code increases.

Erick Espinosa:
It’s ironic. In an AI world, where generating code is easier, the rate of delivery is actually slowing down. Why is that?

Arjun Iyer:
Exactly. Just generating code doesn’t make it production-ready. Tools like GPT or Cursor can help, but shipping to production is a completely different challenge. Validating functionality, performance, security—especially in distributed systems with interdependent microservices—is hard. Ensuring all those components work together is not trivial.

Erick Espinosa:
I keep hearing about “agentic AI.” In your world of shipping software, how valuable are these systems right now? Are you using them?

Arjun Iyer:
We’re actively experimenting. We’ve started with low-hanging fruit—updating documentation, writing simple tests, and scaffolding basic code. These are tasks that don’t require deep thought but still take developer time. GenAI handles those well.

But when it comes to multiple agents collaborating on a complex task—that’s still early-stage. I’m optimistic about their potential, especially in areas like market research or content drafting, not just engineering. So yes, we’re exploring those, but we’re still cautious about complex use cases.

Erick Espinosa:
How soon do you think these agentic systems will become more mainstream and practical?

Arjun Iyer:
It depends on the use case. For writing code and basic testing, we’re already seeing value. Content generation and market research are also promising areas today. I think within a year, we’ll see significant progress, especially given how fast the field is evolving.

Erick Espinosa:
You mentioned bottlenecks earlier. What are the top two things slowing development teams down today?

Arjun Iyer:
First, validating code is hard. Especially with complex testing—functional, performance, scalability, failure handling, security. These non-functional aspects slow teams down.

Second, infrastructure bottlenecks. You need environments to test your code, but duplicating production-like environments isn’t easy. Many teams don’t have enough on-demand environments, so developers queue for access, delaying testing and shipping. That’s a huge bottleneck in cloud-native teams, and one we’re solving at Signadot.

Erick Espinosa:
Do you think big players like Meta or OpenAI deal with this too?

Arjun Iyer:
Absolutely. In fact, it gets worse as teams and systems grow. OpenAI, for instance, likely has a massive production footprint, and simulating that for testing isn’t trivial. The more developers you have, the more contention for testing environments. It’s a real, growing challenge.

Erick Espinosa:
You’d think larger companies would recognize the importance of thorough testing to protect their brand.

Arjun Iyer:
They do—but even then, quality is hard to scale. A buggy release damages trust and can lead to churn. Brand perception is everything. You need to ship fast, yes, but never at the expense of quality. And that’s the real tension.

Erick Espinosa:
Let’s talk about Shift-Left. What is it, and why is it important?

Arjun Iyer:
Great question. Shift-Left means testing earlier in the software development lifecycle. If you catch a bug in production, it’s 100x more expensive to fix than if you’d caught it during development.

By testing during the design or coding phase, you reduce the cost and time of fixing issues. Shift-Left helps you move faster and maintain quality. It’s a crucial mindset shift for modern teams.

Erick Espinosa:
That’s such a valuable insight—and surprisingly under-discussed. What kind of feedback do you get from companies adopting these approaches?

Arjun Iyer:
There’s a spectrum. Some think AI can do everything; others are skeptical. My advice: don’t force-fit AI into tasks that require deep human reasoning. But for repetitive, manual tasks, AI can deliver significant ROI today. Be deliberate and realistic about where you apply it.

Erick Espinosa:
So really, it’s about keeping the human in the loop?

Arjun Iyer:
Exactly. Tasks that involve deep imagination and reasoning—keep those human. But for grunt work, where it’s just labor without deep thinking, AI can shine. Just be cautious and thoughtful in how you apply it.

Erick Espinosa:
Before I let you go—what advice would you give to someone just entering this field? Especially with AI evolving so quickly?

Arjun Iyer:
Tinker a lot. Play with the tools. Experiment. That’s how you build intuition for where these systems help and where they fall short. Prototype ideas, try different use cases, and learn where the real value lies.

I’m optimistic about the future. These tools will significantly boost productivity—but you need to understand their limits and strengths.

Erick Espinosa:
So, have fun experimenting with it.

Arjun Iyer:
Exactly. See where it can help throughout the development lifecycle—from coding to testing to debugging. At Signadot, we’re building tools that help devs ship faster without compromising quality. You can learn more or try our free tier at Signadot.com.

Erick Espinosa:
Sounds like a great resource. Arjun, thank you again for joining us. If listeners want to connect or learn more, what’s the best way?

Arjun Iyer:
Check out our website, Signadot.com. We have a Slack community linked there, and our free tier is open for anyone to try. Join the conversation, share ideas, and explore.

Erick Espinosa:
Thanks again, Arjun.Arjun Iyer:
Thank you so much, Erick.