Software Development Metrics - A Crawl, Walk, Run approach with Allstacks (Part 1)

Have you ever tried to improve something without knowing where you stand today? It's like trying to navigate to a destination without knowing your starting point on the map. Pretty impossible, right? That's why we need a smart approach to measuring our software development efforts. With Allstacks as your metrics platform, you'll get that comprehensive view of where you are now, making the improvement journey much clearer from day one.

So what's this Crawl/Walk/Run thing about?

Think of it like this:

• Crawl - You're just getting started. Baby steps. Figure out where you are now.
• Walk - You've got the basics down. Now you're making real improvements based on what you learned.
• Run - You're doing great and on your way to mastery! Your team is using advanced metrics to continuously optimize.

Makes sense, doesn't it? Let's focus on that first stage today.

Starting to Crawl: Your First Steps with Dev Metrics

The crawl phase isn't about perfection - it's about laying a foundation. It's like when you first start working out - you don't immediately go for a marathon, right?

What should you focus on during the crawl phase?

• Find Your Pain Points
  • What's driving your team crazy right now? Those build times that take forever?
  • Where could small changes make big differences?
  • Look at both technical stuff (like code quality) and process things (like how long it takes to get features to users)
• Pick 3-4 Simple, but Meaningful, Things to Measure
  • Keep it super simple - things you can track without special tools
  • Make sure they connect directly to those pain points
  • Choose metrics everyone can understand (not just the data nerds!
• Get Your Baseline
  • Take an honest look at where you are today using Allstacks' dashboard
  • Track consistently for a few weeks - Allstacks makes this easy with automated data collection
  • Use Allstacks' visualization tools to create charts everyone can understand at a glance

Setting Goals That Don't Make People Roll Their Eyes

Now that you know where you stand, set some goals that:

• Are crystal clear - no fuzzy "get better at quality" stuff
• Can actually be achieved in 2-3 months (we're being realistic here)
• Focus on improvement, not perfection (progress over perfection, always!)

For the next couple of months, keep tracking in Allstacks while you work on those improvements. The platform's comprehensive tracking means you'll always know exactly where you stand. Once you hit your goals - celebrate! Then use Allstacks to identify new areas to improve and keep the momentum going. This continuous feedback loop is where Allstacks really shines.

Getting Started - A Crawl Example:

The following 4 metrics are a good starting point for the crawl phase.  They represent picking a few initial items to focus on at first that are both simple to track and impactful to understand/improve.  

• We have selected 2 “speed” metrics - commit vs complete/cycle time and 2 “quality” metrics - issue bounceback (intra-process) and defects escaped.  
• The reason for this selection is to create a balance between the need to go fast and yet to maintain high quality while moving quickly.

1) Commit vs Complete

In this example, the team’s velocity and completeness against commit is very irregular.  We want to set a goal of stabilizing this, and improving gradually, but steadily.  A way to grow in this metric would be to a) stabilize the commit v complete in a way that it becomes very predictable and b) once stable, begin incrementally increasing the both numbers gradually.

2) Cycle Time

Again in this example, we see more irregular data, likely contributing to the velocity irregularity.  We see Cycle Time varying pretty significantly over the past 3 months.  Getting to predictability is very important in order to successfully plan future work.  Perhaps build out capacity by person based on sprints and add that up for the total team throughput.

3) Issue Bounceback

Issue Bouncebacks seem to be in pretty good shape indicating that the overall attention to detail is in a good spot.  This stability demonstrates good development "hygiene" and likely means engineers are completing unit tests thoroughly, getting good code reviews and collaborating with the QA team on testing strategy for each code delivery.

4) Bugs Escaped

Escaped bugs also look statistically stable.  So as we take a hard look at the 2 speed based metrics above, we do not want to introduce a degradation in quality.  We need to remind ourselves that unit tests, code reviews and test collaborations are vital to overall quality and we cannot skip these steps as we move toward higher velocity goals

Why This Matters More Than You Think

The crawl phase might seem too basic if you're eager to dive into fancy metrics dashboards. But trust me - this foundation is everything. By starting small and getting reliable measurements in Allstacks, you're building a culture where data-driven improvement becomes the norm, not some management fad that everyone ignores.

Remember - the core to these improvements are the people executing them and the work - those software engineers.  Asking them to improve 3-4 related metrics in a timebox - great.  Going broadly with 8-10 measures or more, this is where overzealous organizations make mistakes, resulting in CHAOS!

What's great about implementing this in Allstacks is that while you're "crawling" in terms of your metrics journey, you're already using an enterprise-grade platform that will scale with you as your metrics practice matures. No need to switch tools when you outgrow your initial metrics - Allstacks grows with you.

Next time, we'll talk about the "Walk" phase - where things get even more interesting as we build on these basics and leverage more of Allstacks' powerful features.

Remember: You can't improve what you don't measure, and you can't measure effectively if you try to run before you can crawl! With Allstacks as your foundation, you'll be creating an environment of true continuous improvement from day one.

See you next week for part two of our Allstacks metrics journey!