7 min read

Impedance Mismatch: SRE vs Dev Speed

In the realms of software development and reliability engineering, two forces often find themselves in a delicate dance of balance: Site Reliability Engineering (SRE) and Development Velocity.
Impedance Mismatch: SRE vs Dev Speed

In the realms of software development and reliability engineering, two forces often find themselves in a delicate dance of balance: Site Reliability Engineering (SRE) and Development Velocity. While they serve different functions, their interplay is critical in shaping the efficacy and resilience of the digital services we use daily.

The Impedance Mismatch: A Tale of Two Priorities

As with many great things in life, software development and site reliability engineering are not without their tension points. This tension becomes most palpable when development velocity—the pace at which a team or company can produce and deploy software—collides with the demands of SRE, the discipline dedicated to the availability, latency, performance, efficiency, change management, monitoring, emergency response, and capacity planning of their services.

On the one hand, the main goal of software engineers is to create new features and improve existing ones at a rapid pace. The faster they can churn out these improvements, the better it is for business, customer satisfaction, and, of course, the company's bottom line.

On the other hand, site reliability engineers are the stewards of stability and reliability. They are the gatekeepers who prevent, identify, and respond to system-wide issues that could potentially disrupt a product's service. The faster the pace of change, the harder it becomes for them to ensure stability.

This divergence in focus can create an "impedance mismatch", a term borrowed from electrical engineering, where impedance refers to the opposition that a circuit presents to a current when a voltage is applied. Similarly, in the context of SRE and software development, it illustrates the push-pull dynamic that often exists between these two vital functions. This mismatch, if not addressed, can lead to tension, inefficiencies, and eventually harm the organization's ability to deliver high-quality, reliable services.

This blog post will investigate this impedance mismatch, highlighting strategies to strike a delicate balance between these two seemingly opposing forces. By mitigating this tension, organizations can foster a harmonious relationship between velocity and reliability, promoting an environment that serves the interest of all stakeholders - from engineers and SREs to end users and the business as a whole.

Striking a Balance

How, then, can we manage this tension? Here are some methods I've found effective:

1. Shared Ownership and Empathy

This starts with instilling a culture of shared ownership and empathy. The best outcomes happen when developers care about the reliability of their services, and SREs care about feature delivery and business needs. Encouraging engineers to understand the entire life cycle of a service, from development to production, can help establish this culture.

In practice, this approach can manifest in a variety of ways:

Steps to Ensure Shared Ownership & Empathy

Cross-Functional Collaboration

Encourage collaboration between development teams and SREs from the inception of a project, rather than bringing in SREs at the deployment stage. This allows for an understanding of potential reliability issues from the start and fosters a sense of shared responsibility for both new features and system stability.

Rotate Roles

Consider implementing a rotation program where developers spend some time in the SRE team and vice versa. This direct experience allows each side to better understand the other's challenges and perspectives, leading to more empathetic and effective collaboration.

Joint Postmortems

When incidents occur, conduct postmortems that include both software engineers and SREs. This shared reflection on what went wrong and how to prevent it in the future promotes a joint ownership of issues and their solutions.

Encourage SRE Mindset

Train developers with some aspects of SRE skills and thinking. By understanding concepts like error budgets or being involved in on-call rotations, developers can better understand the impact of their work on the system's reliability.

Unified Goals

Ensure that both development and SRE teams share common goals that are tied to business objectives. This can include both feature delivery timelines and reliability metrics, emphasizing that neither aspect can be sacrificed for the other.

Regular Communication

Establish regular communication channels between the two teams. This could be through daily stand-ups, shared status updates, or joint planning sessions. Open and regular communication helps align priorities and creates an environment of transparency and mutual respect.

2. Error Budgets

This is a concept where we quantify the acceptable level of unreliability for a service in a given period. If a service runs within its error budget, the pace of releases can be maintained or increased. If the error budget is exhausted, the focus should shift to improving reliability.

Error budgets provide a quantitative means of balancing the need for rapid release of new features with the necessity for system stability and reliability. By defining an acceptable level of system error, teams can measure how much risk they can afford to take without seriously impacting the user experience or service quality.

Example in an Ecommerce Application

For instance, consider an ecommerce application. The reliability measure could be defined as 99.9% uptime, which translates to roughly 43.2 minutes of downtime per month, or about 10.1 minutes per week. This is the error budget for the application.

If the application experiences downtime of 15 minutes in a particular week due to the release of new features, the team has overspent its error budget by about 4.9 minutes. This should signal the team to shift focus from releasing new features to improving reliability.

Shifting to Improve Reliability

In this situation, there are several areas where developers could focus their efforts to enhance reliability:

Incident Analysis: The team could perform a detailed analysis of incidents that led to the downtime. What caused the issue? Was it a software bug, an infrastructure problem, a design flaw, or something else?

Bug Fixes: If software bugs are identified as a cause of downtime, developers could prioritize resolving these issues over releasing new features.

Performance Optimization: The team could look at improving the performance of the application to prevent future downtimes. This could involve optimizing code, tuning databases, or enhancing system configurations.

Resilience Engineering: Developers could work on building more fault-tolerant systems. This might involve introducing automatic failover, better error handling, redundancy, or other resiliency features.

Load Testing: The team could perform rigorous load testing to identify potential bottlenecks or failure points in the application. By understanding how the system behaves under stress, developers can proactively address weak spots.

Monitoring and Alerting Improvements: If downtime was not identified quickly enough, improvements to monitoring and alerting systems could be made. The sooner an issue is detected, the faster it can be resolved, and the more the downtime can be minimized.

In essence, once the error budget has been exhausted, the priority should be improving the reliability and stability of the application. By applying this concept, development teams and SREs can have a common, quantifiable metric to balance their often competing objectives.

3. Controlled Change: Baby Steps

One of the most effective ways to bridge the gap between rapid development and site reliability is the concept of "baby steps". This involves introducing changes gradually to mitigate the risk of unexpected system failures and disruptions.

Below are of the most used strategies to ensure controlled change:

Feature Flags

Feature flags, also known as feature toggles, are a powerful tool in this approach. They allow developers to selectively enable or disable features in a system. This means a new feature can be deployed into the production environment but remain 'hidden' behind a feature flag until it's ready to be activated.

This not only allows teams to separate feature rollout from code deployment, but also provides the ability to test how new features operate in a live environment without affecting the entire user base. If any issue arises, the feature can be toggled off instantly, reducing the impact of failure and making it easier for SREs to maintain system stability.

Canary Releases

A similar concept is canary releases, named after the practice of using canary birds in coal mines to detect dangerous gases. In this context, a new version of a service is rolled out to a small, controlled group of users before being made available to everyone.

Like the feature flags, canary releases allow teams to test the waters and monitor the system for any potential issues. This approach ensures that any problems that arise do not impact the entire user base, and can be rectified before a full-scale rollout.

Both feature flags and canary releases are powerful tools that can help mitigate the impedance mismatch between development velocity and site reliability. They allow developers to innovate at speed while giving SREs the means to manage and mitigate risk, striking a balance that promotes both the rapid delivery of features and system stability.

Remember, taking baby steps with these gradual rollout strategies isn't a sign of timidity; it's an emblem of maturity and sophistication in the realm of software development and site reliability engineering. After all, slow and steady often wins the race.


Balancing the needs of Site Reliability Engineering and Development Velocity is a nuanced task that requires a multifaceted approach. It begins with instilling a culture of shared ownership and empathy, encouraging cross-collaboration and shared goals among teams. Adopting error budgets, helps set expectations, and shift to reliability work when its needed. Lastly, taking baby steps through the use of feature flags and canary releases allows for a controlled change, ensuring a stable system while maintaining innovation. With these strategies, we can navigate the impedance mismatch, promoting a harmonious synergy that leads to both reliable systems and rapid development.

If you found this blog post engaging, consider subscribing to our newsletter to receive our latest insights straight to your inbox.