There’s nothing worse in a software development environment than dealing with the prima-donna developer. You know the one who constantly tells you how they could get another job making more money elsewhere, how his code is cleaner, how he stays up later, and on and on.
Just because a person thinks she or he is better than everyone else – – and let’s say that he is actually a better coder – – they aren’t helping you build better software because the best software is built by teams, not individuals.
For a small business or start up company that isn’t a pure technology company, its not uncommon to hire one programmer at a time (especially when you are either first learning to develop software or just trying to keep your costs down as you figure out your needs). However, we have learned that in the end you will spend a lot more in lost productivity or in hindsight hiring mistakes when you rely on individual developers.
With individual developers you run the risk of keeping a developer around who hates his job and creates sloppy code that is difficult to uncover before its too late. We had a passive-aggressive developer like this who we kept around for years and oh the mess he left behind! It took us years to redo much of the code that this developer had created and the costs were likely more than what we even paid to this developer to begin with.
Hiring a team of developers provides the best long-term return on investment if they are well managed. We always recommend that you utilize an agile approach to software development. Here are a few reasons development teams work better than individual developers:
(1) More brains to solve complex issues
(2) Diverse skill sets
(3) Healthy competition
(4) Accountability at daily stand up meetings
(5) You won’t get hijacked by your developer
(6) All work belongs to and is committed daily to the company repository
Here are some of the negatives that can happen in teams:
(1) Personality clashes
(2) Carrying low-performing team members
(3) Negative attitudes can spread to other team members
(4) Tendency to be hands-off could lead to misdirection
A team of developers should consist of 3 key oversight and support positions:
(1) Software Architect,
(2) Project Manager and
Developing code without an Architect, Project Manager and Tester will likely create a jumbled mess of code in a few years and cause many headaches in the mean time. Without an architect there is no assurance that what is being developed is part of a master plan that will be scalable into future versions. Without a project manager there is no person watching over a developer’s time and schedules making it harder to keep them accountable. Finally, using your customers as “testers” for new software updates is not a long-term model that will work. Thus, all three of these positions are critical to developing your software asset.
How to Move to Teams
If you currently have a prima-donna developer and you are concerned what will happen to your solo developer if you do move to a team, we recommend you wait no longer put a plan in place. Your plan should include hiring the new team and putting your solo developer on that team so he can get used to the process. It will take time and the transition could cause some turbulence but in the long run you will find yourself in a better position once the team is up to speed.
In summary, no matter what direction you decide to take in your software development projects, you need to own your projects rather than your engineers owning them. If you fail to manage them and the direction they are heading then you may end up being a slave to your developers and not maximizing your investment.