Why Imposter Syndrome in Tech Is So Common—and What We Can Do About It

I feel like an imposter. Not the version at the end of Scooby Doo mysteries where meddling kids yank a monster mask off my head. But the kind, at this very moment, where I’m pretending to be a writer. And in real life, too, at my day job, where I’ve been a software developer (or some reasonable managerial version of the same) for over 20 years.

I write code and comments, plead for pull request reviews, attend countless meetings, and respond with emojis all day long. And although I’ve been successfully doing this for decades now, I actually don’t feel like a software engineer when I’m writing code any more than I feel like Kurt Vonnegut while I’m trying to write what you’re reading right now.

What’s a software engineer supposed to be, anyway? If we could buy a programmer action figure off the shelf, there are a few configurations we could imagine from what popular culture tells us. Do you want the “fleece vest and computer science degree from a name-brand university”? Or the “hoodie with homemade mechanical keyboard, never awake before noon”?

The reality is that the field of software engineering is so incredibly broad—spanning many industries and a variety of different capacities—that these dated clichés can’t come close to capturing the many personalities in a group that some say includes more than four million developers in the U.S.

But there is one unifying condition for many of us: imposter syndrome. First described as “imposter phenomenon” in 1978, imposter syndrome is characterized by a persistent belief that your work accomplishments and success aren’t deserved, and a feeling that you’re about to be revealed as a phony at any moment.

Perhaps partly because of the outdated perceptions and stereotypes about developers, many of us don’t feel like we belong in this field.

How does having imposter syndrome manifest in the sprint-to-sprint, ticket-to-ticket life of a developer? A 2011 paper mapped the cycle of behaviors and thinking of someone struggling with imposter syndrome—let’s adapt it to the typical workflow of a developer.

Across the top of this diagram you can see a simplified and generic code workflow: get a ticket, work on a ticket, complete the work, then get the code reviewed and approved.

As you start to work on a ticket, you might not understand an element of the task—sometimes it’s a technical issue, or maybe it’s just a lack of context or detail—which can lead to feelings of anxiety and doubt. This is where that imposter syndrome voice in your head might start to unleash negative self talk: “I *should* understand this ticket…everybody else knows what this means but me. I can’t ask for help or they’ll all know I’m a fraud.”

And even after pushing through and successfully completing the task, any positive feedback as your work is reviewed and approved might feel hollow, as that same imposter syndrome voice will minimize the accomplishment with: “I only figured it out by asking ChatGPT for the fix!” A healthy perspective on the same result, taken from a growth mindset, might celebrate, “Yay, I’m learning new things!” But instead imposter syndrome says, “No, no, I just got lucky.”

Or let’s say you couldn’t complete the task, or you received critical, maybe even hostile feedback on your code commit: That imposter syndrome voice will start to growl and go into overdrive with, “They know I’m faking it,” or, “I’m going to get fired.” 

Sound familiar? These anxieties are quite common for developers—whether you experience them when starting a new job, joining a new team, or even just learning a new framework or library. I can’t get a majority or even plurality of developers to agree on linting rules or pizza toppings without a flurry of angry emojis, but some studies say as many as 82% of people across all industries—and most tech employees (58%) and computer science students (57%)—wrestle with imposter syndrome. Over time, imposter syndrome may drive you to experience burnout or symptoms of depression, or even cause you to quit programming completely.

What makes imposter syndrome so common and drives these anxieties in the field of technology, specifically?

We all start off as hackers.

Do you remember the first moment you started “coding” something? Maybe it was a cheat code while playing Sims 2? Maybe it was tweaking CSS on a MySpace page? Your first experience coding may have been messing something up, and (optionally) fixing it again. There is joy in the power to change something as complex as a video game, or a page on the internet, without understanding all of its underpinnings.

Fast forward to your coding career: It might feel like some of your colleagues are gifted at software development, understanding all of those hidden pieces, while you remain a cheat-code hack. The tech industry mythos of the college dropout turned billionaire founder is ingrained in our culture, which can create a belief that everyone in tech is merely moments away from the fame and fortune of launching their own unicorn startup. Meanwhile, that imposter syndrome voice might whisper: “Everyone here is exceptional, and they will find out that I am not.”

But what you might see as programming superpowers in others is often the gift of context: familiarity with the codebase, experience with the processes, and knowledge of the people. With any new job, language, codebase, or project, we all start again, not from the beginning, but building upon what we know, oftentimes with the same sense of exploration and “hacking” that began the journey.

So rather than getting stuck in a while loop of worry about what you might not know, remember that everyone starts as beginners, and even your most confident colleagues perhaps once felt, or even still feel, the worries of imposter syndrome.

Maybe we were raised this way.

Studies have found that early family relationships affect the development of imposter syndrome. Authoritarian parents, for example, push their children to high levels of academic achievement, holding them to unachievable standards and ideals. Helicopter parents, on the other hand, hover over all of their kids’ activities and schoolwork to protect them from pain and disappointment, which may cause the children to internalize that overprotection as a lack of competence.

These kinds of foundational family relationships may be at play as you wrestle with feelings of imposter syndrome, and as you define your sense of self as a developer and as a working adult.

A great tech job isn’t just about working on the hottest languages and newest tools—it’s also about finding the right work culture, where your relationship with authority (e.g., your manager, senior colleagues, even existing code) isn’t fraught with baggage and mislaid expectations. You can gain a lot of ground against imposter syndrome by finding a work culture where you can fulfill your very individual needs and expectations for structure, organization, and personal growth.

So be sure to understand your needs and research a company’s work culture before you accept a job offer. Remember that interviews are a great opportunity for you to understand whether you’d feel safe and supported working with the people on the other side of the table.

We crave a sense of belonging—and we don’t always find it.

There’s a warm, fuzzy feeling when you’re part of a team where you feel accepted and included, and know you can just be yourself.

That sense of belonging is something we all crave at work, and perhaps value even more in a collaborative role like software engineering. Being a good and valuable software developer isn’t tied to a specific gender, race, or background, it’s something anyone can excel at. But when you’re part of a team, a company, or an industry where you’re one of the few from an underrepresented group, it can definitely amplify those pesky imposter syndrome feelings, on multiple levels, even if you’re knocking it out of the park with every code review.

Diversity plays a huge part in making a feeling of belonging possible, and the tech industry as a whole still has a long way to go. So finding companies that actively work on fostering a more diverse and inclusive environment within technology teams can be a critical part of your job search. Asking questions during the interview process about diversity—of race, gender, family, even programming preferences, etc.—could go a long way to understanding how open others are to different points of view, and to give you a sense of how comfortable you may ultimately feel.

Our work is constantly changing.

One thing that’s certain in tech is that things will change. The languages, the frameworks, and the tools all continue to evolve at a rapid pace. Keeping up with the latest trends is, frankly, exhausting. Skills that were once valuable change over time. And while there’s still a seat at the table for COBOL experts, it’s also very easy for any developer to feel like they’ve fallen behind the times.

The industry itself is vast, with many different ways to write, debug, and run code for all sorts of industries and consumer use-cases—there’s no way to “learn all of programming,” to become the Ash Ketchum of computer languages. Frankly, you might never feel a sense of mastery with software development, as there’s always something new to learn and myriad solutions and approaches to any given problem.

Imposter syndrome can not only make you feel bad about yourself, but also get in the way of the learning you need to do to succeed (e.g., “I’m just a front-end dev, I’ll never be…”). That, in turn, can meaningfully inhibit opportunities and career growth. Ultimately, your tech career is more than just the sum of your programming skills today, and building a career is more of an art than a science, especially when so many of the roles and functions are just as new and dynamic as the tech itself.

Be open to chances to learn and grow, and observe how your value to your team and business increases as you move forward. And don’t get locked into one vision for your career. With the addition of remote and hybrid workplaces on top of new tools and roles, there are so many opportunities that are within reach, even if you need to build on what you know today to get there.

If Shaggy, Fred, and Velma were to rip off my writer’s mask, they’d find a code geek who’s battled imposter syndrome throughout his career. Especially as someone who took a left turn from the arts and academia into tech, learning how to code on my own in the earliest days of the web when tables were brand new and CSS had yet to be invented.

How did I get over it? I don’t know if you ever just get over it. It took some time and reflection to grow into who I am—and to know what my own values are as well as where and how I can be valuable to others. Working with colleagues and for managers who are open to discussing issues of personal growth and the challenges of imposter syndrome certainly helped. But I never resembled any of those programmer action figures, and I’ve learned by now that I probably never will. And that’s worked out just fine.