Overcoming the challenges of a fast growing and diverse Development team
We recently launched an Instagram campaign to shed some light on the day to day antics of Usabilla’s impressive Development department. Our Social Media Strategist, Neal, put together a 10-part series exploring the challenges and evolving priorities of a fast growing and diverse team and you can revisit the story in full right here.
We’ve almost doubled in size over the last year! But for a development team, this comes with challenges — mainly, being able to create good code while staying in sync as a unit. Why is good code so crucial to our success? The simple answer is because code changes. Maintenance, modifications, and adjustments are always present in software development. Good code both allows and adapts to this change, whereas bad code leads to a drain on resources. In order to achieve this, we first needed to take a step back and think about what code quality meant for us.
“Quality” is subjective, and the term ‘code quality’ is often thrown around. We need to understand, however, that different teams around the world often have different priorities when it comes to software development. What we consider high-quality code is code that is built around the core values that we as a team have defined, and contains the elements that we have determined are most important to our goals. To us, as a growing team, there are four elements that we need to always consider — simplicity, efficiency, robustness, and extensibility.
Simplicity helps in all aspects of coding. Specifically, it makes the code easier to maintain, because it’s easier to understand from someone else’s point of view. Think of it like taking notes that you need to share later on. Anyone reading your notes should be able to understand what you’re trying to say, and this is exactly what it should be like for anyone that joins us in the future. The less time we spend trying to understand messy code, the more time we can spend creating awesome features and products.
Code needs to be efficient and focused. Code that focuses on one goal becomes smaller and easier to replace. We need to ensure that bit of code does one thing, and that it does that one thing very well. We prioritize ‘simple’ over ‘complex’ and strive to create code that isn’t needlessly complicated.
Robust code is often explained as code that’s difficult to break. It’s a quality that’s sometimes overlooked yet is incredibly important. Ensuring the code we write is robust means that it becomes easier to change, and becomes more resistant to bugs. This allows us to worry less about errors or crashes, and spend more time enhancing the features of our product. We work on achieving this by clearly representing business rules in the code.
Extensibility is an important quality, but what’s even more important is that it is practiced in moderation. Too much extensibility means we risk making our codebase more complex, and as a growing team we need to avoid too much complexity. Done right though, building code that is extensible allows us to handle specific scenarios without spreading rules all over the place to affect other areas of code. Finding the balance isn’t always easy, but this is where the experience of our team plays a big role.
We have a pretty diverse team, which is important in software development. Diversity, in all aspects, allows for more creativity and better problem solving. Every coding problem has infinite solutions, each more adequate to a given scenario. Having colleagues with such varying backgrounds allows us to consider different angles to every problem, and even get a better representation of our target audience.
There are challenges when you have such a diverse group of people working together. Every individual has a different thought process, as well as personal preferences for things like workstation setups. With a team like this, it’s important to find that balance between giving people enough personal space where they can work the way they like to work but ensure that they still have that integration into the team. This is where having coding standards and shared values comes in. Having this set of core values — this anchor — is what ensures a team stays in sync.
9. Shared Values
Every development team needs an anchor that helps them stay in sync. For us, that anchor is the set of 15 values that we formed as a team. Finding this common ground was a process that’s straightforward, but challenging. For our team, each member contributed by sharing the 3 values that mean the most to them. These values were divided into a category: technical (how we write code) or human (how we treat each other). Every opinion matters, therefore we discussed every value that’s written. We then looked for clusters — groups of similar words — to find the values that are most commonly shared.
What’s important to remember is that a team’s values are not set in stone. What works for a team of 10 may not work for a team of 20. Each new member brings change. Over time our core values will adapt and improve to accommodate an ever-growing department. This means we need to make a conscious effort to ensure we keep empowering our team, and involve every new member in this continuous process. With the foundation we’ve built though, we’re confident we’ll be able to keep learning and tackle the challenges that come our way.