How Do We Measure The Efficiency, Agility, and Velocity Of An API-Centric Way Of Doing Things?

One of the benefits of doing APIs that we have always touted as API believers, is that APIs increases efficiency. We are able to move faster. Be more agile. Increased velocity of what our teams can deliver by reducing the size and scope of teams and the API infrastructure they can bring to life. It is something I’ve said over and over in my storytelling, and as I work to scrutinize the words I use in my storytelling, and work to justify the meaning behind my work, I’m looking to better understand I how I can back up this claim. The first question I ask in these situations is how do we measure whatever is in question, and quantify this change we claim is going on. So, with this, how do we measure the efficient, agility, and velocity that APIs are brining to the table. 

I guess I am trying to better understand what different organizations are measuring when it comes to understanding all of this. We generally say that we can move faster, but specifically what does moving faster actually mean? I am trying to think through some of the details of what I should be measuring with each team, so that I can better articulate and visualize what exactly faster means. Which of these areas matter the most?

  • Teams - Are we measuring the speed at which teams operation, helping them get more work done?
  • APIs - Are we measuring the number of APIs delivered? If so, how are we quantifying the scope of each API being delivered?
  • Applications - Are tracking the number of applications being developed? If so, how are we defining the scope of each App?
  • Releases - Are we measuring the number of version releases? If so, are we looking at major, minor, and impact of patch?
  • Features - Are we tracking on the number of features being delivered that actually impact the end-users?
  • Tickets - If we are using JIRA or other ticketing system, are we just satisfying some metric regarding the number of tickets closed?
  • Partners - Are we doing more with partners? Delivering what they want at a speed we were never able to realize before?

I’d love to hear from y’all regarding what efficiency, agility, and velocity means to you. Are you actually measuring, quantifying, and reporting upon the velocity you’ve realized from doing APIs and microservices and / or going API-first? Or is everything still just anecdotal and just talk? If I was to question my own velocity measurements it would center around APIs and API enabled capabilities. I can definitely deliver APIs much faster than I used to, but without any actual benchmark about the scope of each API I’ve developed, I can’t really articulate that my 2014 APIs were much slower than my 2019 APIs, any more than I can say my 2014 APIs are bigger than my 2019 APIs. I really don’t have any cornerstone to lean on when I am claiming that I’m moving faster, it is all just anecdotal. 

This is a subject I will be revisiting often. I have a lot of questions. I have very little data to back up my beliefs. I’ll be talking with different folks I know to better understand if they are indeed moving faster, and how they are measuring things, or not. Another aspect of this discussion I’m thinking about is if we are doing things faster, what are we doing with all that time we’ve saved? I’m guessing the answer is we are doing more! Then I would like to know more about how we are measuring this as well. Again, are we doing more APIs, applications, releases, features, and tickets? How are we tracking it? Also, has the size of teams shifted along the way? There are just so many questions to be answered about this fundamental claim I have been making for some time now, and I’d like to be able to do a better job of backing up what I say with actual real world data and examples.