Back in the bad old days of battleship grey UI’s, rounded corners made up with GIF files and “Best Viewed With Netscape Navigator 3.0” badges, businesses just wanted their software teams to ship – quality be damned! So which software team KPIs would lead to delivering better? In todays modern software world, things are much different. Technology leaders are expected to deliver on time.
Software development teams are also expected to meet modern demands:
- Quality software that doesn’t crash
- Software that is fast
- Software that communicates how users are using the software, and what their experience is
- That the software delivery process is repeatable, and the team is agile
Competition is fierce in the software industry, team members are expensive, and doing great work keeps the lights on.
“What gets measured, gets managed”
It’s important to measure these metrics to help the entire team manage the user experience. Let’s get real for a second: your team is employed because you have customers. If your software is terrible, you will lose customers (71% of users will stop using software after an error!)
What we see at Raygun, is new customers who are usually coming from no system at all. They’ve had issues, and appreciate that the Raygun Software Intelligence Platform would help the streamline their processes, make customers happier and grow their businesses.
It’s understandable – our industry is maturing, and expectations increase with maturity.
What should you measure?
At Raygun, we hold senior development team members accountable to several metrics that Raygun can automatically track:
- Users Affected By Bugs: Frankly, error counts are misdirection. If you have 10,000 errors that affect one customer, it’s not as bad as 500 errors affecting 250 customers. Measure the affected customers on a monthly basis, with a goal to reduce
- Median Application Response Time: Forget averages, they lie. The Median response time is what 50% of your customers experience (or faster). Track that, and hold the team accountable to achieving a time or better. Performance makes money – 40% of users will leave a website that takes more than 3 seconds to load!
- P99 Application Response Time: Medians are great, but we also need to appreciate the upper limit. We choose to track the P99 – the time taken for the 99th percentile of users. This will normally be slow, but we want to make sure it’s more like 5 seconds slow, not 25 seconds slow. We don’t often track P100 as it’s the domain of total timeouts, bad bots that hold connections open and is generally misleading about real users
- Resolved bugs >= New bugs: Platforms like Raygun will group bugs by their root cause. This makes it easy to manage the bug count, not the crash count (instances of a bug encountered). The team should be fixing bugs at least as quickly as they are creating them (in a brown fields project, ideally resolving more than are created)
These four metrics will make your software stand out as being best-in-class. It will oblige your software teams to:
- Improving user experiences with less crashes
- Improving user experiences with faster software
- Reduce technical debt accumulation. It won’t fix all technical debt, but fast bug free software is nearly always better to work on than slow buggy software
How the Raygun Software Intelligence Platform helps
We’ve all been in situations where a metric was important, but that it was hard to compute. What happens? You stop tracking it because it’s too hard (hey, there’s a reason we like computers right?)
The Raygun Platform gives you the software intelligence you need, all in one place. This means the above metrics are all available in realtime. No need to use disparate tools to collect different metrics, that don’t enable correlating and seeing your platform completely. We also added improvements to our Dashboard feature, which enables you to get your key software performance metrics up on a TV display for the whole team to see. The dashboard also gives tech leads the ability to take a quick glance at software performance.
The Raygun Platform also works with more than 30 programming languages, across mobile, desktop, web and back-end server software. You need 360 degree visibility into your software.
You can also push notifications about these metrics into your existing tools, like Slack & HipChat. Your team can execute faster when these metrics are right under their nose, avoiding accidental slippages on key metrics.
What about KPIs like Monthly Active Users, Geographic break down, feature tracking etc?
These metrics are very important to track, but are typically tracked by Product Managers, Marketing Managers, etc. We will do a follow up post about how these software team KPIs can be tracked alongside these metrics.
Which other metrics do you track?
I’d love to get some comments about other ways that software leaders are tracking their KPIs, and what those KPIs are. Building great software takes a lot of effort, but tracking the right metrics makes it easier.