What are the metrics by which you measure your agile development process?

If you're really interested in the intersection of old school management metrics and Agile, check out Israel Gat's The Concise Executive Guide to Agile. Rather than just focusing on how things should be in Agile happy-land, it tries to give managers metrics they can use to hook-up with measurement maniac sad-land. Here's my quick review of it: http://www.redmonk.com/cote/2010/08/25/execguide/

Some great answers and insights have already been provided above, I think there are two perspectives from which you can look at this question: The business stakeholder perspective The development team perspective Firstly, I fully agree with William's point about business stakeholders being interested primarily in outputs: Did we manage the deliver the features or release the code which we set out to do at the start of a sprint? Did we manage to deliver in accordance with the user stories and acceptance criteria that we defined together with our business owner? Like Raghavendra suggests, an important challenge is to ensure that the business is on board when it comes to (1) defining the features and its associated outputs/benefits and (2) reviewing the functionality once it has been built. In an ideal world the business owner collaborates with the development in planning each sprint and is closely involved throughout the sprint (attending standups, making sure the right outputs are being built, etc.). In this scenario,  accepting sprint outputs by the business owner should therefore be a seamless process. Secondly, from a development team perspective, metrics such velocity can be useful indicators of team progress and average turnaround. However, I do see the limitations of using velocity as a primary progress metric: I personally find that velocity by itself doesn't tell you that much - Yes, it gives you an indication of turnaround speed but measured against what? As Parker points out above, due to the lack of an absolute scale to measure velocity against, it's sometimes hard to tell whether a team is doing well or not. If anything, measuring velocity on a regular basis should give you an indication of how the developers are doing; whether they are being fairly constant, any spikes in activity, etc. Again, even in this scenario, I feel that velocity tells you only half the story. What was the nature of the stories worked on in a particular sprint? Did anyone game the system? Where there any specific factors or circumstances which should be taken into account? I increasingly use more elements of the 'lean', Kanban approach whereby I tend to use metrics such as 'lead time' and 'cycle time' as a starting point to explore and highlight e.g. lessons learned, beneficial/detrimental factors, etc. I see these kinds of metrics more of a means to an end, rather than definitive, stand-alone metrics.

I like the fact you mentioned they should be actionable as there is no time for vanity metrics. And since http://blog.in-sight.io/the-first-step-to-improving-at-anything-is-to-start-measuring/ I think you did a great job on finding the most important metrics to start with. Also if by any chance you are using http://pivotaltracker.com as your agile project management tool, I linked some examples of how you could get those metrics with a dashboard called https://www.in-sight.io/. First, some more metrics that we find useful to track: Scope creep: how much work gets added after the team commits to a certain amount of work (iteration). This is very helpful if the team is often interrupted with new incoming stories during the iteration (http://help.in-sight.io/knowledge_base/topics/burndownchart). Projection of the current iteration: will we be on time or not (http://help.in-sight.io/knowledge_base/topics/burndownchart). Work in progress: not allowing the members to open too many story at the same time. Often, if they do, the stories are either not clear enough or they are stuck on those stories and need help. It is wiser to fix this situation instead of starting another story. The http://help.in-sight.io/knowledge_base/topics/wip chart handles this scenario. Technical debt: this one is about giving some love to your code, having high code coverage, keeping it https://en.wikipedia.org/wiki/Don%27t_repeat_yourself and maintaining it regularly. You can track this with http://help.in-sight.io/knowledge_base/topics/jenkins for example or share a http://help.in-sight.io/knowledge_base/topics/code-climate-rating  for everyone to see. Here is how Insight handles some of the metrics you mentioned: Volatility: a http://help.in-sight.io/knowledge_base/topics/volatility chart. Effective velocity:  http://help.in-sight.io/knowledge_base/topics/stories-by-type chart. Time to accept: http://help.in-sight.io/knowledge_base/topics/cycle-time and http://help.in-sight.io/knowledge_base/topics/average-cycle-time charts. Acceptance rate: excellent metric, that is not yet covered, although it is pretty easy to infer from other charts like http://help.in-sight.io/knowledge_base/topics/stateflowchart.

I would add these ideas: Net Promoter Score by those using the output of the team, as well as those who need to work with the team Number of process experiments the team tries as well as how often does an experiment fail (meaning they are challenging their comfort zone of process changes) How far is the team from releasing to production at each point in time Time to fix - How fast are defects closed, Blockers/Impediments dealt with ROTI (Return on Time Invested) on meetings - Do people feel the meetings are effective for them. Typically a great indicator of team morale and happiness. Are they able to be more and more focused (lower WIP) over time? This leads to more agility/liquidity.

I am struck by "evaluating how well the team is doing".  It seems the "technical" measurements are not what you're primarily interested in (velocity is in fact an excellent measure of HTTID, if you are talking about success/improvement at knocking off tasks/stories). I have found that the hardest thing about Agile is encouraging terseness. As the team gains confidence, trust, courage, and of course familiarity with the process, the meetings will tend to be shorter and more focused, the stand-up (or similar) will flow more easily and stay within time limits, and so forth.  This results in more clear ideas than muddled ideas.  The user stories get shorter, for example. Arguments become informed back-and-forths which stay on topic. You might find useful measurements there, about time usage, regarding communication efficiency.

Assuming your product backlog is not growing (much) faster than what you implement in your sprints, the following metrics might help. Evaluate your sprint backlog at the end of the sprint cycle. If what you set out to do in that sprint are not completely done or you end up moving items from the sprint back to your product backlog you have a problem. In each sprint, you would find bugs and fix them (not all of them maybe fixed in the same sprint.) Like sprint backlog, the bug fixes should progress well too, so track it. Having product management and engineering in the same room for daily scrums is one thing, but having the product management to agree on what's being built, is completely different matter. So, create metrics on this and track it. Note that agile model gives the product management the flexibility to try out different things so a given feature may end up being reimplemented over and again. While this is acceptable from process perspective, keep an eye on overdoing it. Otherwise, engineering will look like a hamster running in its cage - busy, but going nowhere.