Optimizing for Developer Productivity Creates a Winning DevEx
Developers often face compounding pressures to meet business objectives while maintaining operational excellence. But being hands-on, which some advocate for, doesn’t always translate to better developer experience (DevEx).
We hear about DevEx a lot in every keynote, blog post and vendor pitch — and that term is starting to lose its meaning. Don’t get me wrong, DevEx is important. But while it’s often discussed as a broad concept, focusing on tangible productivity improvements — like streamlining the loop of coding, testing and debugging — delivers more immediate and measurable results.
Developer productivity (DevProd) is not about having 50 tools at your disposal. It’s about improving the experience, speed and productivity with the right kinds of tools. With that mindset, it becomes easier to focus on what truly empowers developers — removing obstacles and creating an environment where they can focus on building exceptional software.
And in my experience, the heart of DevProd lies in what we at Ambassador evangelize as “optimizing the inner dev loop to increase developer velocity.” A core cycle of activities developers perform, say, while working on a feature or squashing a bug. It’s the flow of:
- Writing code
- Building the application
- Running and testing
- Debugging
- Committing code
This loop repeats, sometimes dozens of times a day — the core loop of coding, building, testing and debugging. The smoother and faster this “inner dev loop,” the more productive developers become. And they can iterate more quickly, solve problems faster and develop features at a quicker pace.
Many Potholes to Patch
But this is not happening because of the “outer dev loop,” which, in contrast, encompasses the broader development life cycle, including but not limited to tasks like planning, collaborating, integrating and deploying. This flares up friction and increases context switching, often fragmenting workflow and disrupting developer focus, which eventually increases the downtime tax of the inner dev loop.
One of the biggest challenges developers face is the burden of repetitive manual tasks and inefficiencies in their workflows. Manually configuring environments or updating dependencies slows down developers and prevents them from focusing on solving real problems. Also, inefficient feedback loops are super frustrating. When developers are stuck waiting on feedback from tests or deployments, it breaks their flow and kills momentum. These delays hurt productivity and, honestly, morale.
Containerization was supposed to improve developer productivity — and in some ways, it did — but you really need to consolidate (and manage) the right kinds of tools to keep your developers in the inner loop. But even then, the added system complexities will increase technical debt.
Say, for a developer making a small change locally, the cycle typically takes four to five minutes. If all goes well, they move to the next task. If not, they keep working while the issue is still fresh. And, assuming a developer works six hours of work a day, a developer could complete around 70 iterations.
Applied strategically, this level of productivity can address technical debt. But consider all the noncoding tasks in the development life cycle: planning, task assignments, code reviews, status updates, CI/CD management, performance monitoring, incident response, retrospectives and more. While necessary, these activities take time away from the core coding loop. We can’t eliminate them, but it’s clear the current approach isn’t ideal.
And so, in a time when distractions and the need to switch between various tools — causing mental fatigue and decreased efficiency — make it exceedingly difficult for engineering leaders to streamline workflows and improve development velocity with limited resources, leaning toward DevProd is an imperative need to address the challenges their organizations face.
By investing in DevProd, engineering leaders aren’t just optimizing workflows, they’re investing in the very foundation of their software and reclaiming the lost velocity that lies in streamlining the inner dev loop flow. A unified solution can significantly help optimize this.
Scaling Up While Slowing Down
Containerization is great for the modern cloud native way of building and architecting applications. Containers enable companies to scale and serve vast user populations across diverse environments, providing consistency and portability, ensuring applications run reliably regardless of the underlying infrastructure. But this boon for operations teams comes at a cost for developers — the dreaded “container tax.”
The desire for seamless, cloud native development often clashes with the undifferentiated heavy lifting of managing complex container configurations, dependencies and networking. Containers, while radically changing deployment and production, often introduce significant complexities into the development workflow. And so, developing for containerized environments has become harder, not easier.
Instead of streamlining the inner dev loop, containers often disrupt it. Developers find themselves wrestling with Dockerfiles, Kubernetes manifests and a host of other container-specific tools, pulling them away from the core task of writing code and building features. Debugging becomes more challenging, forcing developers to navigate container logs and understand intricate network interactions. And spinning up a development environment can itself turn into a complex orchestration, slowing down iteration cycles and hindering rapid experimentation.
Many tools have simplified container-based development. Docker made containers more accessible, and Kubernetes offered solutions for orchestrating container deployments. But these, while valuable in their own right, haven’t fully addressed the core challenge: preserving the developer’s inner loop within a containerized world.
That’s because they often add layers of abstraction that, while useful for production, create friction for developers trying to iterate quickly and efficiently. The promise of easy container-based development has often fallen short, leaving developers struggling with the complexities of the container ecosystem.
Yet developers love local setups, even when working with containerized applications, whether those environments are local or remote because the familiarity and speed of local development allow for quick iteration and faster feedback loops. But integrating local changes with remote containerized environments can be very challenging and potentially slow down the development process.
Developers shouldn’t have to become container experts to stay productive. Blackbird, newly integrated with Telepresence, offers a new approach to container-based development. It allows developers to focus on what they do best — writing code — while abstracting away the complexities of container management. By providing a dedicated, hosted production-like development environment, Blackbird empowers developers to reclaim their inner loop, enabling them to iterate quickly, test thoroughly, and build exceptional software, even in a containerized world. And with the addition of Telepresence, developers can still choose to connect with live remote clusters when they need to, all while staying in the comfort of their local machine.
Removing Bottlenecks With the Right Tooling
Engineering leaders looking to improve DevProd need to start by listening to developers. Understand where they’re struggling and invest in solutions that address those specific pain points. If you really want to improve DevProd, try to understand how streamlining your developer team’s feedback loop can make an immediate impact. Developers hate waiting, so anything you can do to speed up processes — whether it’s automating tasks or improving testing environments — pays off in productivity and morale.
Let them stay in the inner dev loop where they do their best work (coding). And don’t overlook AI. As I pointed out in Ambassador 2025 Predictions, AI is becoming essential for automating repetitive work and giving developers more bandwidth to focus on high-value tasks.
AI has been a game changer for tackling manual work. AI-powered solutions can automate mundane tasks like configuration management, letting developers focus on the creative and complex parts of their job. Getting the right tools creates seamless workflows for API development, which is incredibly impactful.
You want to seek out technology that will help you accelerate feedback cycles and make it easier for developers to stay in a flow state. Whether it’s ephemeral environments for testing or streamlined AI-powered API tools, these technologies remove friction and let developers do what they do best.
Stirring Up a DevProd Culture Initiative
It all starts with empathy. Leaders need to deeply understand what their teams are going through — what frustrates them, what slows them down — and work to remove those obstacles. Creating a culture where feedback is welcomed and experimentation is encouraged matters. When you empower developers with the right tools and foster a collaborative environment, developer productivity naturally follows.
