June 3, 2022

Code Ownership: Empowering Engineering Teams to Fix the Bugs that Matter Most

Every day we use applications to engage and transact with customers, increase productivity at work, and even wind down at the end of the day – and we expect them to work flawlessly every time. That’s why application stability has become a key performance indicator (KPI) for businesses to maximize retention and grow revenue.

Fortunately, BugSnag makes it easy to help engineers focus on the bugs that matter and maximize software development velocity. The result is a win-win-win for developers writing better code, users avoiding production errors, and stakeholders seeing greater development velocity and better user retention.

Let’s look at how you can empower engineering teams to take ownership of their code and quickly fix the bugs that matter most in multi-team apps.

Application stability is a critical KPI for software businesses, and code ownership is essential to maximizing stability.

What is code ownership?

Code ownership is the idea that individual developers or teams are responsible for the features they create and deploy. For example, suppose that an ecommerce application has two teams responsible for user conversion and ecommerce. If there’s an error in the shopping cart, the ecommerce team owns the code and would be responsible for a fix.

Figure 1: Git commit activity suggests code ownership is an effective way to reduce bugs. Source: Microsoft

There are three categories of code ownership:

  • Strong code ownership – A developer takes ownership over a specific section of the codebase and exclusively makes changes to it. If someone else needs to make a change, they must get permission from the owner to merge them.
  • Weak code ownership – A developer takes ownership over a specific piece of code, but anyone can make changes to the code. Unless they’re making large changes, developers don’t necessarily need permission to update the code.
  • Shared code ownership – The entire team owns the codebase and can make changes anywhere. 

Most development teams use a combination of these approaches. Highly complex pieces of code may be the domain of a single team or engineer (strong code ownership), but in general, developers regularly contribute to the wider codebase. The sweet spot is typically between 50% and 90% code ownership for an average file in the codebase.

BugSnag makes it easier to achieve strong or shared code ownership in multi-team apps where routing bugs can quickly become a challenge.

How to prioritize bugs

Most developers are familiar with error logging tools, such as Splunk and Loggly, but they don’t help prioritize errors by impact. And even worse, developers must have deep expertise in these tools to make sense of errors when unstructured data surfaces. As a result, developers spend a lot of time simply identifying errors and high-priority bugs take longer to catch.

There are several ways to prioritize bugs:

  • VIP customers – You can track bugs that impact critical customers, such as enterprise users versus free trial users. That way, if there’s a problem, you’re addressing the most costly issues before moving onto lower-impact errors.
  • Critical functionality – You can track bugs that impact critical business functions, such as a checkout process. For instance, a checkout failure could result in a complete revenue loss, making it more important than other bugs.
  • Service Level Agreements – You can track bugs that impact SLAs to avoid any costly violations. For instance, enterprise users may have 99.99% uptime SLAs, meaning any degradation to their service is critical.
Figure 2: BugSnag lets you measure priority by events, users, or other metrics. Source: BugSnag

BugSnag makes it easy to add custom filters to search for events by custom metadata added to error reports. Then, you can direct these errors to the relevant developers or teams to address them efficiently, rather than having developers pull issues from a queue. The result is fewer high-priority bugs impacting production users and greater velocity.

In addition to business-focused benefits, efficient bug routing is a boon to developer happiness and productivity. Developers spend less time tracking down bugs and more time on building new features. By keeping developers happy, you can foster a better workplace culture, while minimizing the turnover that many tech companies face.

Increasing productivity

Every organization splits time between building new features and squashing bugs. But, for better or worse, stakeholders tend to measure productivity in terms of shipping new features. As a result, developers should focus their bug-squashing time on critical errors and avoid spending too much time on bugs that don’t significantly impact user experience.

Stability scores can help inform these decisions:

  • User stability score – The user stability score is the percentage of users that were error-free within a given day. When these percentages are too low, it may be time to dive into fixing bugs that degrade performance.
  • Session stability score – The session stability score is the percentage of sessions that were error-free over a given time period. In addition, you might look at sessions associated with a specific workflow if thresholds differ between workflows.

BugSnag makes it easy to measure user and session stability across the application. Team leaders can use that information to determine when it makes sense to dive into bug troubleshooting versus working on new features. That way, it’s easier to maximize velocity without compromising on product quality – a win-win for developers, users, and stakeholders.

In addition, when it’s time to fix bugs, BugSnag also makes it easy to segment errors and intelligently route them to the right developers to avoid notification fatigue. Rather than dealing with an onslaught of bug notifications and trying to decide what’s relevant, developers know that every notification they receive is a bug they need to act on.

Create a culture of ownership

The most effective software businesses have a culture of ownership. While developers may already take ownership over certain pieces of code, successful businesses expand the concept of ownership throughout the organization. In other words, everyone feels comfortable flagging problems, suggesting improvements, and helping out when issues arise.

Many teams foster a culture of ownership through OKRs, or objectives and key results, whereby individuals, teams, or the organization set objectives with measurable results. In addition, teams may use a build-measure-learn feedback loop to continuously improve and incorporate feedback from every team member.

Agile tools and processes can help achieve these goals. For instance, retrospectives are a common way to alter and improve products and processes. Meanwhile, tools like BugSnag can help teams easily track and prioritize defects while measuring application stability over time.

The bottom line

Application stability is quickly becoming a critical KPI. A combination of ownership culture and effective tooling can help development teams quickly prioritize bugs while maximizing velocity. That combination helps developers, users, and stakeholders since it efficiently balances the need to push new features with the need to squash bugs.

If you’re interested in BugSnag, watch our free webinar discussing some of the most common use cases, or sign up for a free trial today.

BugSnag helps you prioritize and fix software bugs while improving your application stability
Request a demo