Improving Team Cost-Performance for Spending Your Budget Wisely and Effectively


January 2023 Release Notes

Here’s what’s new in our January 2023 Release Notes:

* Tables Columns Sorting Improved
* Reconcile Commits Count Between KPI Card and the Table
* Efficiency Tab Improvements and Efficiency KPI Cards Align

Read More »

These days, the cost of everything seems to be increasing, but so should our means for getting more mileage from every dollar, euro, pound, and peso. This is especially true in software development. Successful software (at a minimum) is delivered according to specifications, on time, and within budget. Developer skills and wages factor heavily in defining success. How to optimize these when they come together is the focus of team/project management. So, here, we’ll look at different ways improving team performance can lighten the load on all that transitory inflation.

Oh yeah… everyone’s agreed it ain’t transitory.

A Development Team by Any Other Name…

To keep this focused, if a developer is working on your project – they are part of your team. This qualification is necessary because today’s “software development team” can be a mix of in-house and a variety of outsourced developers. “Variety” here means freelancers from Upwork sites, independent contractors, augmented staffing from an agency, partnership arrangements with development agencies, etc.

For Team Management, specifics don’t matter too much – if a developer is working on your project in any capacity, they are part of “your team.” In this regard, you “should” have the means to optimize each developer’s contribution to your project. They should be working from the same code repository, be involved in the standups/retrospectives and other meetings. They should also be responding to your feedback.

The distinction is necessary as further budget and performance optimization can be realized in Vendor Management when working with and comparing cost, performance, and responsiveness across multiple contractors and staffing agencies.

What Can be Improved?

Everything. While efficiency can only ever be increased to 100%, and bugs reduced to 0,
there are no theoretical ceilings to productivity or “force multiplier” components like teamwork and automation. In Gitential, we associate these and all coding efforts to four main drivers:

  • Speed – issues of velocity and productivity.
  • Quality – avoiding bugs, defects, security vulnerabilities requiring rework.
  • Efficiency – avoiding wasted effort in tasks and processes.
  • Teamwork – efforts to improve communication and collaboration.

There are many, many software development performance metrics. Cycle Time is an excellent high-level metric as it is an aggregate of all other metrics. An improvement in any other metric will almost always reflect in some improvement to Cycle Time. Cycle Time is one of the best ways of tracking the overall profitability of development efforts.

How Do You Improve Team Performance?

The Agile Methodology and “Best Practices” in Software Development provide ample knowledge-sharing opportunities. DevOps can be instrumental in improving team processes, cross-functionality, and ultimately automation. DataOps shares essential data with all stakeholders further promoting cross-functionality.

AI, in turn, accelerates training and cross-functionality while 10x’ing how fast you can generate immediately actionable insights to help your team and each of its developers. AI won’t replace you, as it serves only in an advisory capacity. Managers keep decision-making authority as there are plenty of things that today’s AI cannot and should not know – like whether your developers are eating right, sleeping well, and getting some exercise while socially distancing, of course.

In relative, but doubtfully an “exact” order of effectiveness, our options include:

Knowledge-Sharing Opportunities

  1. Standup Meeting “Tips of the Day”
  2. Sprint Planning
  3. Peer Code and PR Code Reviews
  4. Walkthroughs
  5. Resource Library Examples
  6. AI-driven “Next Best Actions”
  7. One-on-One Meetings
  8. Objective and Key Results (OKR) Meetings
  9. Internal workshops, webinars, conferences, and conventions
  10. Continuing Education Programs

These all add up. That’s 200-260 “standup tips” per year, at least a dozen retrospectives with another ~3 tips each, two-dozen one-on-one meetings and we’ve just scratched the surface. Well, unless we’re doing a Pareto Principle Analysis in which case, probably 51% of our tips are coming from those “daily tips.”

How Do You Maximize Team Capabilities?

While there are some different dynamics between companies with existing teams and brand new startup teams, managing “Team Intelligence” is about cultivating each developer’s skill and professional development. It’s about helping each developer be better coders, learn new technologies, get experience with different applications – tackle new challenges.

There’s all kinds of “boring stuff” out there – and the Great Resignation is showing what happens when you leave good developers to do boring stuff. Of course, there are some developers who don’t mind a little boredom here for having dealt with the chaos of high-growth startups several times.

  • Team Intelligence management starts with hiring strategies and processes.
  • Addressing skill development during new dev onboarding can provide a positive first impression and mutually set expectations for what many devs want and many companies need, most.
  • Optimize a rotation to more evenly and meaningfully distribute mentoring efforts relative to programming language or technologies and developer strengths/weaknesses.
  • Use team metrics to identify good walkthrough opportunities to tackle team-wide challenges.
  • Use Agile methodology and best practices (as detailed above) to continuously share knowledge – standup meetings, code review commenting, retrospectives,
  • Meet with team members 1-2x per month for one-on-one meetings to 1) see how they are progressing, 2) what their current greatest challenge is, and 3) get feedback from them on what you can do to make it easier for them to be the best coder they can be.
  • Provide developers needing a break with opportunities to attend conventions, webinars, and other great new virtual events no longer requiring you to pay per diem or travel expenses.
  • Continuing education programs – but as we’ve covered before in Why Developer’s Leave, there are plenty of online programs, paid and free, that you can integrate into your own internal training program.

For many companies, internal apprenticeship and mentoring programs may be the easiest and fastest way to ramp up cost-effectively on new skills fast.

How Avoiding and Reducing Code Complexity Can Help Your Budget

In Is It Worth Having an AI Assistant?, we showed how an engineering manager could use manual analytics to generate a 1,000% to 10,000% annualized ROI by helping a developer reduce their defect rate. Mean Time to Repair was the main variable.

An AI Assistant makes finding how to make that improvement possible at least 10x faster.

Reducing defect rates earlier is always a great way to avoid wasted effort and boost overall productivity. It’s by no means the only way. Some teams could be very diligent in hunting down and killing bugs like Starship Troopers and ultimately have few to no bugs on release. Rare, but possible. Defect rate is just one of the metrics that we can work on…

Code complexity is nefarious, too – inflating Cycle Time from the code’s inception through the time it’s retired.

What influences code complexity?

  • Developer knowledge/skill/experience (as applied to code logic and structure).
  • Ambiguous or ill-defined tasks.
  • Choice of programming languages.
  • Highly modular vs tightly coupled components.
  • Optimizing how story points are broken down to match team capabilities.
  • Team size and structure.
  • The addition of many new developers.
  • Practicing Test-First Development can reduce it.
  • Entropy/Code Rot over time.

What does the equation look like for reducing code complexity? Part of that goes back to our look at Peer Code Reviews factored on the basis of US average of $52.95 per hour according to BLS.

  • 100k LOC reviewed at 400 LOC/HR = 250 hours for an avg. US cost of $13.2k
  • 80k LOC with lower code complexity for 500 LOC/HR = 160 hours or $8.5k

Less code that’s easier to read can easily reduce the cost (waste) of code reviews by 36% – with variable multipliers for savings on debugging, refactoring, and the ramp-up time for all future developers.

Software with an average lifespan of 7 years will cycle through 3.67 teams beyond the first with an average turnover rate. Many developers agree that it can take 3-6 months to become comfortable with a new codebase. Ostensibly, less complex code can reduce that period of elevated inefficiency.

It’s rare, but possible to find a single metric that will provide a massive boost all at once. There are many metrics. Efforts to improve each can bring frequent and small though still significant returns on ROI so you can get more out of your budget.

Did you like our content?

Spread the word

Subscribe to Our Newsletter

Don't miss our latest updates.
All About Software Engineering Best Practices, Productivity Measurement, Performance Analytics, Software Team Management and more.

Did you like our content?

Spread the word

Subscribe to Our Newsletter

Don't miss our latest updates. All About Software Engineering Best Practices, Productivity Measurement, Performance Analytics, Software Team Management and more.