Shameless Developers: How to Manage Imposter Syndrome within Your Team
It’s no secret that tech professionals are stressed out and anxious due to a fast-paced, high-stakes industry culture. But within that demographic, developers specifically are experiencing feelings of shame, fear, and inadequacy regardless of high quality of output.
Sound familiar? This is an example of Imposter Syndrome, a phrase used to describe the behavior pattern of self-doubt regarding personal and professional accomplishments, in which one may fear being exposed as a fraud, despite actual success.
We hear the phrase Imposter Syndrome used primarily in the context of race and gender, and in the developer world, women and BIPOC (Black, Indigenous and people of color) communities certainly experience it in profound ways. It’s also a widespread issue; the resulting anxiety is experienced at higher levels within developer teams than among other tech industry workers.
Let’s take a look at some strategies for identifying feelings of shame within your dev team, and mitigating those issues before they start to impact your teams’ performance.
First, let’s recognize that shame and anxiety within a dev team can negatively affect a company’s bottom line. A study by the Institute of Software Technologies in Stuttgart found that software developers produce a lower quality of code when mentally-exhausted or depressed. Less productivity means less company growth.
Imposter Syndrome and shame can cause anxiety-ridden employees to procrastinate, miss deadlines, distrust their teammates, and more. It also can create more employee turnover as a result of burnout.
With that in mind, consider these approaches to addressing shame and Imposter Syndrome within your dev team from the top down.
Situations Likely to Trigger Shame
SNAFUs:
When things go wrong, that voice of doubt seeps into a developer’s head. “Was this my fault? Did I build the patch correctly? I must have been moving too quickly and made a mistake! Am I going to be replaced because of this? My teammates would have been more careful.” Whether it’s a critical fix or technical debt, SNAFUs are a surefire gateway to shame and fearful thinking.
Data Breaches and Security Issues:
Many InfoSec communities use a shame-based approach to handling exposure to risk and outside threats. Even if this isn’t the case on your team, it may be deeply embedded in the way your developers think. Encourage discussions about security breaches to make the issue less charged. As a leader, telling a story about how you made a mistake — and how you fixed it — will make others on your team willing to be more candid during the discussion.
A Code or Design Review:
The amount of time, care, and effort that goes into software building can lead developers to feel an emotional connection to their work. Isolated creative work and internal processing make these projects feel like a personal reflection of a developer’s worth. Developers feel highly vulnerable during a code or design review, and anything less than stellar feedback can lead to a shame spiral.
Signs a Developer Is Experiencing Shame and/or Imposter Syndrome
The aforementioned shame-triggering scenarios aren’t meant as a deterrent from giving honest feedback to developers. Rather, they are meant to provide context into the ways shame can rear its head. As a manager, being aware of those triggers helps one prepare to keep teams on track by mitigating shame and Imposter Syndrome right away.
People show emotion in different ways, and part of being a manager is paying close attention to individual behavior in order to keep teams functioning as well as possible. These days, that type of observation is more challenging than ever, because teams are not even in the same rooms. Opportunities for subtle and respectful behavior assessment are limited, so use Zoom meetings and Slack or intranet interactions to infer as much as you can (within reason). Are your developers exhibiting any of the following shame-related behaviors?
- Regularly keeping video off on video calls, and rarely participating vocally.
- Constantly blaming other employees for mistakes or acting overly defensive.
- Struggling with deadlines and time management.
- Fear of others seeing their code, or resistance to participating in open source projects.
- Beginning questions with, “This might be a dumb question…”
- Frequently using laughter as a deflector.
Strategies for Mitigating Shame Among Your Developers
Think before you speak. If someone is hesitant to ask a question or, as previously mentioned, starts a question with, “I have a stupid question,” consider your response thoughtfully. Making a lighthearted sarcastic remark might seem like a way to show this developer that there are no stupid questions, but that can come across as shaming as well. Instead, thank them for the question, answer genuinely and calmly, and state that the question is not stupid.
Pay attention to your team’s behavior. Observe tone during conversations, facial nuances on video calls, and also consider what isn’t being said.
Normalize both positive and negative user feedback by implementing well-oiled mechanisms for understanding and discussing those insights. It’s good for developers to hear user stories, as long as you, the manager, regularly emphasize that the feedback is a learning tool, not a way to track team or individual failures.
Take blame out of the equation by shifting the focus of SNAFUs. Implement a mindset that looks at mistakes and individual errors as part of a holistic learning structure. SNAFUs provide opportunities to improve processes and handle future events in a positive, productive way.
Maintain continuous delivery in order to minimize risk and lower performance anxiety by normalizing regular exposure of your team’s work.
Use pair programming across multiple activities in addition to programming. This builds trust within teams and can help prevent the stresses that come from long periods of individual work.
Practice Agile iteration, and transform mistakes into learning opportunities, that can always be redone with sprints.
Lastly, do your research and become well-acquainted with how shame works. Build trust by practicing empathy, and set a reasonable precedent for how mistakes are handled.
Imposter Syndrome and shame in your developer team can lead to more serious mental health issues, which ultimately will negatively impact productivity and hurt your bottom line. Employee retention will also suffer as a result of not addressing these issues. Do your dev team and your business a favor and identify employee confidence, shame and Imposter Syndrome issues before they become a problem.
Feature image via Pixabay.