Achieve Incredible Results by Maximizing Your Software Talent
Let’s face it, when managing any enterprise software product, there are never enough software talent on the software development team to do everything we want to be doing, at the speed that we want to be getting it done. So many important needs compete for the software team’s bandwidth: bug fixing, technical upgrades, customer-requested enhancements, new product offerings, redesign/re-architecting of existing offerings, etc. Within any organization, these competing needs require good structure around backlog prioritization. In a privately held, self-funded organization like TalentQuest, this requires laser-focused optimization in all the ways that you staff our team, architect your software, maximizing your software talent and managing your operations if you are going to succeed at making our clients happy while also broadening our software product offerings.
The Right Talent
It’s an understatement to say it is a competitive market out there for software talent. Recruiting (just like job hunting) can be a slog of interviews that don’t work out, and it can be tempting to settle for the “good enough” choice. On a small team, the person you choose can either positively or negatively impact the team’s dynamic. We need to know without a doubt that, not only is this candidate the right fit for us, but also that we are the right fit for the candidate. To ensure this, we utilize our own behavioral science offerings internally. This includes TQ Assessments and Talent Insights to get software-driven insights into the candidate’s fit within the team, as well as our own Consulting Services to get deeper input from a trained psychologist. There have been many examples of technically skilled candidates who I have passed on because they were not likely to be a good fit for our team and culture. That is a difficult choice to make, but it always pays off handsomely when you finally find that candidate that checks all the boxes.
The Right Culture
To get the most output and effectiveness from a small team, retention and engagement are key. It takes time for members of a software team to build their experience and knowledge with a product that has a large technical footprint. Their value comes not only from their knowledge of the product’s technical architecture, but also from a deeper understanding of the domain. Again, the market for software talent is a competitive one, so keeping your good talent from being lured away requires creating an environment that people want to stay in. Beyond fair pay and benefits, this is where it is critical to create a team-oriented environment with no egos, a learning mindset, supportive and flexible leadership, and opportunities to break the routine with new things. Motivators vary from person to person, but it is universal to want to be paid fairly, feel like you are growing, and feel like your employer cares about you as a person. Getting the team operating efficiently and effectively requires establishing a culture that satisfies these needs, so look at your leadership first!
The Right Architecture
Having the right people and the right culture in place are linchpins to operating lean, but without the right architectural strategy and mindset, you can quickly create inefficiencies in the work that thwart your efforts by either a) slowing down the work, or b) requiring you to increase your headcount (and cost) to get the work done. Experienced software professionals know that sometimes adding more developers can exacerbate the problem, where a single well-placed architect can create efficiencies in the design and reduce your need to hire more folks. Some basic architectural tenets that are critical for operating lean are:
- Find patterns and build a framework – Repeating yourself is, by its nature, inefficient and doing so in application code can cause both a maintenance headache and buggy systems when similar things behave differently. Designing a shared, yet flexible, framework allows reuse across the system and provides consistent behavior.
- Fix it once (and for all) – One of my favorite terms used in software development is “spaghetti code.” This is where the code is so poorly structured that it is nearly impossible to follow, and you have no way to tell how and where to make the correct change without unknowingly breaking things. You don’t have to be a coder to recognize the symptoms of spaghetti code. The recognizable pattern is when there are multiple iterations of bug fixing in a specific area, and each bug fix introduces a new bug that perhaps was not there before. Trust me, sometimes it pays off more in the long run to go ahead and absorb the upfront pain to rewrite that stuff now, rather than continue to let it be a constant thorn for both you and your customers. Everyone on the team will be happier when they can stop going back and working on the same thing over and over, and instead focus on other, more interesting, stuff.
The Right Structure
One of the challenges that comes with operating as a small, efficient team is creating good balance in how you allocate bandwidth to the various competing needs of an enterprise software platform. Technical support, customer feature requests, strategic initiatives, and bug fixing all compete for time. Without a well-defined structure, the allocation of the team’s bandwidth can easily be pulled toward focusing on one of these areas while neglecting the others. We have addressed this by creating a specific structure for each of these areas which allocates our team appropriately and serves them in a balanced way. Dedicated months, rotating teams, and client advocacy from our Client Success team are some of the tools we use to ensure we are meeting the needs of all our customers, both internal and external.
A common response to slow-performing software is to solve the problem by adding more processing power. This may make the issue go away, but we often see that the similar result can be achieved by finding a way to optimize the code to make better use of the horsepower that was already available to it. Similarly, an engaged, cohesive, well-structured software team can deliver at the same level of output and quality as a much larger team that does not follow these practices with its talent and work structure.
