Under the proper guidance, businesses thrive. This is why a change in leadership is often met with a cocktail of emotions ranging from careful optimism to fear of the upcoming future.
Lately, we’ve seen a mixture of both. Some of the biggest names in tech, including Klarna, Unity, Spotify, and even the grandparent of the Internet as we know it—the eponymous Google themselves—have experienced troubling times on more than one occasion.
In order to offset the projected financial uncertainty, these companies have resorted to relatively straightforward measures: layoffs.
Now, “layoffs” are the favorite topic of precisely no one. From the perspective of employees, it’s almost always something that happens suddenly; it’s also unprecedented and deeply unfair.
From the vantage point of employers, layoffs are necessary for the company to survive and remain competitive in the long run. However, layoffs come with risks of a tarnished reputation if things go south.
Amidst all that, somewhere between the layers of project development and human resources lies dormant the concept of effective communication. In other words, how these layoffs are handled (both privately and externally) can either open the doors for future collaboration or close them up for good.
Arguably, announcing these layoffs could’ve been handled way better if only there were a more involving attempt at effective communication between the two concerned sides (employers and employees).
This is just one of the many examples of improper communication. The public backlash that followed could’ve been avoided by talking with the employees, addressing all of their concerns, and handling their departures internally.
Instead of striving to make at least someone happy, these major players found a way to make everyone unhappy.
In the following paragraphs, I’ll try to examine two significant observations regarding effective communication in tech teams:
- Why communication is important
- How communication can improve
Let’s jump right into it.
The importance of effective communication in software development teams
As we’ve seen, proper communication (or the lack thereof), could shape the opinion of those that find themselves near the epicenter of what is being communicated (the information).
This can shape the listeners’ opinions for the better or worse, depending on how the information has been presented (and the nature of the information itself).
However, communication isn’t something that is typically associated with software engineers, at least as far the stereotypes go. One such stereotype is that the broader public imagines developers as “geeky” hermits who sit behind their laptops and tick away at their keyboards for hours on end.
While this could definitely be the case for some individuals, reality paints a different picture. Communication is one of the most underlooked soft skills in programming and software engineering. It’s what ultimately makes the product work, and it’s key to building a successful, collaborative environment.
As developers move up the ladder, it becomes increasingly important to communicate, and do it well. One of the major differentiating factors between junior, mid and senior developers is the knack for effective communication.
In fact, one prerequisite for a senior developer to get the job is to be proficient in communicating effectively.
But, how about the whys? Why is effective communication considered a key pillar in software development?
Solving a software engineering problem successfully depends on two major factors:
- Strong technical skills of the development team
- Effective communication cross-functionally across multiple departments (more on this later)
Whether someone works individually or as part of a team, developers depend on each other’s knowledge and skills. This ensures that all tasks are delegated accordingly, and each team member takes full responsibility to successfully complete a bigger, overarching goal.
This collaborative process can also involve teams that aren’t software developers by trade, including QA (quality assurance) teams, finance teams, data scientists, designers, and more.
Reduced probability of errors
In software development, regardless if the collaborative effort happens inside an office or during a remote working session, communication barriers do exist.
One of the ways to solve this problem is by communicating regularly (but not micromanaging). People will become more inclined to share data, and, in theory, information will start to flow more freely (and naturally) than before.
An added benefit of this approach is that work efficiency (and productivity) will also increase in the long run.
When project deadlines, deliverables, and requirements are properly communicated to all parties, the probability of making errors shrinks significantly.
In turn, making fewer errors means decreased expenses, leading to significant cost savings over short and longer periods. Ultimately, the minimization of errors results in a positive impact on the overall business profitability.
When information flows freely between all team members (from all departments), developers can complete their tasks in a (relatively) shorter period.
On the other hand, whenever a developer has to explain the same thing more than once, there is a high likelihood of encountering project delays. These delays are expected in software engineering and usually “creep up” whenever there's ineffective or non-existent communication between developers, and project leaders in the team.
Communicating effectively allows developers to achieve a proverbial (and practical) working flow state, leading to increased productivity overall.
Improved client management
If there are two things that companies would like to have the foresight to predict, it often comes in the form of:
- Understanding what their clients need
- How to adequately meet their customer’s demands
All of this can be catalyzed through client meetings, proper access to relevant information, and updating the project status via progress reports.
Effective communication improves the overall state of client management and results in a trajectory of steady growth.
A faster resolution of conflicts
Working in teams means working with multiple people with different skills and backgrounds. This can sometimes result in poor communication, and lead to conflicting (but preventable) viewpoints in the group.
The probability of having disagreements can show up anywhere, and in situations of:
- How to write code
- What approaches, methodologies, and tools to use
- How to implement and manage processes
And this is just the tip of the iceberg.
However, to successfully resolve a conflicting situation, the team members must resort to effective communication. This is one way to achieve success in a tightly packed, highly collaborative environment.
How to improve communication in software development teams
In the past, hiring software engineers didn’t necessarily mean that recruiters were looking for the best communicator out there. Professionals from branches such as programming, graphic design, or UI/UX design were mostly being qualified over their technical skills, and not their communication style or other types of soft skills.
Interviews were centered around things like education, the ability to work with existing and new technologies, and the candidate’s hands-on experience with real projects they were working through.
Hardly anyone was considering a quality developer to be also an excellent communicator.
Thankfully, now things have progressed to a point where good recruiters are considering all aspects of a candidate’s portfolio, including the ability to communicate effectively.
Still, that last part is often overlooked by many. On the flip side, good developers don’t have as much time to invest in honing their communication skills compared to, say, legal professionals or human resource managers.
The nature of their profession dictates otherwise. Developers mostly try to solve software engineering problems (planning, debugging, quality assurance), and rarely have time to give lengthy speeches, or participate in two-hour meetings, especially if their position doesn’t absolutely demand it.
However, the prolific emergence of multiple new technologies has put developers in a tough spot. The question arises: how should they allocate their time? By learning new frameworks, honing old stacks, or getting to know how to communicate their ideas to other people well?
The truth exists somewhere between those lines. And, just like in an RPG game or a D&D session (shoutout to the gamers out there), everyone has a fixed number of points to invest in some skills, at the expense of other skills.
Developers don’t live on islands (except former developers like Bill Gates), and, more often than not, they work in teams with other developers in a collaborative environment.
Here are several instances where improving your developers’ communication skills can help build a cohesive and unified team.
Talking with leaders
To be able to explain the nitty-gritty details of the project to their team leaders, the developers have to be excellent communicators.
If the team leader comes from a software development background, then this shouldn’t be an issue. However, if they don’t share the same skills, it’s likely that there could be room for miscommunication.
In other words, developers should know how to communicate with people who aren’t developers themselves. If they are unable (or unwilling) to do that, things become exponentially more difficult (i.e. deciding on a budget, extending deadlines).
The solution is practice. And practice comes with the job. The important thing is to recognize the potential of a particular developer and then train them to communicate better whenever the opportunity arises.
An example of a genius developer who also communicates well is none other than John Carmack, the grandfather of modern FPS games. He had the longest podcast interview with Lex Fridman, signing in at more than five hours in a single session!
Becoming a leader
If one of your developers has a knack for preparing, organizing, and leading projects, there will come a day when they’ll probably want to become leaders (instead of just acting like one).
However, running a software development team takes a lot of effort, with some additional politics sprinkled in for good measure. In turn, politics is just that: talking and convincing people to understand your point of view.
The solution is: open communication with everyone on the team. Practicing effective exchange of information includes the ability for goal-setting, managing expectations, and properly delegating tasks across teams and departments.
If a developer manages to “rally” the rest of the team members to support their point of view, that’s a leader in the making.
Note: effective communication is vastly different from persuasion or simply being charismatic; being able to differentiate between those three is, in a funny twist of fate, what ultimately makes a good leader.
For any developer, not understanding how people think outside the confines of their technical team can be detrimental to their future career progression.
More often than not, there will arise a need to place a developer on a team with people from multiple backgrounds and skills. This could end up being very exciting, or for those who aren’t ready to take up the challenge, very frustrating.
The solution is: practice some more. Good communication is a mixture of speaking effectively and listening actively.
The more time a developer spends trying to explain the product to peers with limited understanding, the better they (the developer) become at face-to-face communication.
As you can see, effective communication is often the one thing that unites people with different skill sets to work together and—work effectively.
Most of the time, when the company experiences tangible friction between two (or more) team members, it can often be solved by directly and openly communicating what everyone is experiencing about the hurdles they are facing.
As a result, resolved conflicts can lead to stronger bonds between the formerly conflicting sides in a better way, or at least better than any team-building exercise or event could ever achieve.