Productivity Ratio: Understanding the “invisible work” of software development

Curated by: Sergio A. Martínez

That’s part of the reason why productivity in this context is a tricky thing to track. Sure, you can see how long it takes to reach the end goal and measure it against timelines and expectations, but that doesn’t take into account all the nuances of software creation, as well as the challenges of debugging, refactoring, tweaking, editing and other tedious but crucial elements of every successful project. And this is further complicated by progress not always being linear — as soon as you start working on a project, it’s almost certain things will follow their own kaleidoscope-like paths that don’t always make sense from the outside. 

With all that, it might seem that tracking productivity is like nailing jelly to a wall: not an easy task by any stretch of the imagination, and sadly without a one-size-fits-all solution. Doing the required following isn’t impossible, though, but it requires finesse and forethought to obtain meaningful results. It also requires being aware of the “invisible work” going into the development of an application, and it requires having a complete understanding of how that many pieces fit together. Unfortunately, for some teams, ignoring the tediousness of tracking productivity can be seen as more desirable than going through the hassle. However, with the correct approach, any team can achieve such a goal.

Getting ratio’d

Working with other professionals like designers, business analysts, or testers, is part of every software development project, so good collaboration skills are necessary to reach any goal. Furthermore, making sure that the tools you are using are appropriate for the task ahead can have a dramatic impact on how successful the project would turn out to be in the long run. All these requirements mean that a positive outcome demands a spectrum of skills, which makes the whole process more challenging, and not all of them are obvious at a first glance. In the words of this Crossing the Equator article:

“This invisible work increases the communications gap between the hidden, almost abstract world of coding on the one side and that of marketers, purchasers, and investors on the other. It’s a gap that can cause frustration and misunderstanding and can lead to employee turnover and a slowdown of business growth. It is usually the responsibility of engineering leaders to close this gap.”

In other words, measuring “invisible work” can be difficult due to the complexity of any project. While time and effort can obviously be used to gauge progress, many intangible elements must be factored into the equation, but it’s hard to quantify the value of research, problem-solving strategies, code refactoring, and investigating emerging technologies that all help to improve software quality. In addition, developers must often adjust their efforts on the fly if stakeholders change their expectations or new information comes in. As a result, measuring invisible work requires an experienced team who understands what needs to be tracked and how to factor it into the overall process. And one of the more interesting approaches to this comes from a very simple formula: productivity ratios.

Productivity ratios in software development are the gauge by which you measure whether or not a process is successful, indicating the amount of work completed versus the amount of time and effort expended. In other words, it looks at how much time and resources have been invested in a project, such as coding and bug fixes, against the end result. The productivity ratio, consequently, it’s an important metric for gauging how effective a development team is at producing quality work. And understanding how to calculate it can be an invaluable tool for ensuring a project’s success. The formula to do so can be expressed as the following:

The tricky part, however, is how to define what the input and the output mean in the context of development. The most common approach is looking at the basic resources that go into the project (work hours, number of developers, cost per hour, among others), against a specified result, like development milestones reached, user stories, pull requests, and many others, with the general idea that something is being produced continuously. 

The result of the equation is then compared to a baseline (industry standards, or past development story, for example) to obtain an estimate of the total productivity of a given team. But how does this tie back to the invisible work involved in software development? Coming back to the Crossing the Equator article:

“It’s a human-focused thing. It also applies to collaboration, knowledge sharing, and team-building activities. Successful organizations build products that customers love, which can only happen when the right people are involved and treated correctly. Teams cannot afford to hire people who merely hit the keyboard to write code without any profound understanding of or connection to the end user. Understanding the business means understanding its processes and goals and ensuring full team alignment.”

A different way to look at development

In short, without a holistic view of development, a productivity ratio cannot work as is because a lot of the effort is not directly apparent in the final product (like planning, writing documentation, ensuring clear communication between stakeholders, managers, and developers, implementing and maintaining the adequate tools, observing security, refactoring the code, etc.), but it’s required to guarantee the timely delivery of a product, its quality, and the overall success of it. 

After all, putting all the focus on coding is not enough and in fact can lead to disaster if other aspects of the project such as design, testing, debugging, and the actual use case are not taken into consideration. Without properly assessing these elements a lot of issues can arise while rolling out the software to customers resulting in wasted effort and resources. That last part is key: developers should take an all-encompassing approach by focusing on the final users as the overall destination of the whole process, and what they are getting from the whole ordeal is, perhaps, the most important point of all. Consequently, an effective productivity ratio should be defined less in terms of input/output, and more like:

The core of this approach is to stop seeing the development process as an isolated black box where effort goes in and results come out, and instead get into a mindset of the “total work” output by a team against what the client and final user will be receiving. This should not just be an abstract idea but rather a value that’s central to all efforts during production, helping align everyone with a clear goal. Additionally, when strong ties exist between a software development team and its users, trust is established allowing for up-front feedback before any changes or upgrades would be made, all but ensuring that technical implementations fit with user expectations. Bottom line – all software development projects should prioritize the user experience, helping teams align their efforts from day one. Making sure everyone understands and is deeply invested in this user focus allows for more meaningful and consistent collaborations internally, bridging the gap between the visible and invisible work. Ensuring there is a clear baseline for the productivity ratio, will end up manifesting into an ideal, successful product that satisfies users completely.

The Key Takeaways

• Productivity is always an important concern for any software development project because it can give a clear picture of the effort and resources put into development.
• One of the biggest challenges of tracking productivity is the “invisible work” involved in creating a successful application, which is never obvious in the final product.
• A successful approach might be the “productivity ratio” that measures the input against the output of any project, but it needs to be used carefully to consider invisible work.
• To that end, keeping the focus on the final product that the user will be receiving can give a better idea of the productivity of a team, comparing the ratio of effort put in versus what the user will be getting.

Scio is an established Nearshore software development company based in Mexico that specializes in providing high-quality, cost-effective technologies for pioneering tech companies. We have been building and mentoring teams of engineers since 2003 and our experience gives us access not only to the knowledge but also the expertise needed when tackling any project. Get started today by contacting us about your project needs – We have teams available to help you achieve your business goals. Get in contact today!