Software Engineering - Chapter 2. How to Work Well on Teams

Posted on By Guanzhou Song

People are inherently imperfect—we like to say that humans are mostly a collection of intermittent bugs.

Celebrity is a big part of it. Humans have a natural instinct to find leaders and role models, idolize them, and attempt to imitate them.

Being a genius is most definitely not an excuse for being a jerk: anyone—genius or not —with poor social skills tends to be a poor teammate. The vast majority of the work at Google (and at most companies!) doesn’t require genius-level intellect, but 100% of the work requires a minimal level of social skills.

If you spend all of your time working alone, you’re increasing the risk of unnecessary failure and cheating your potential for growth. Even though software development is deeply intellectual work that can require deep concentration and alone time, you must play that off against the value (and need!) for collaboration and review.

But because you’re working in secrecy, it’s impossible to solicit advice from your mechanically inclined friends.

Bus factor (noun): the number of people that need to get hit by a bus before your project is completely doomed.

Ensuring that there is at least good documentation in addition to a primary and a secondary owner for each area of responsibility helps future-proof your project’s success and increases your project’s bus factor.

When you become stuck on something absurd, how much time do you waste pulling yourself out of the hole?

This is how we keep code quality high and make sure our software is evolving correctly, bit by bit. The current DevOps philosophy toward tech productivity is explicit about these sorts of goals: get feedback as early as possible, test as early as possible, and think about security and production environments as early as possible.

This is all bundled into the idea of “shifting left” in the developer workflow; the earlier we find a problem, the cheaper it is to fix it.

A great team makes brilliant use of its superstars, but the whole is always greater than the sum of its parts. But creating a superstar team is fiendishly difficult.

Let’s put this idea into simpler words: software engineering is a team endeavor.

High-functioning teams are gold and the true key to success. You should be aiming for this experience however you can.

To reach collaborative nirvana, you first need to learn and embrace what I call the “three pillars” of social skills. These three principles aren’t just about greasing the wheels of relationships; they’re the foundation on which all healthy interaction and collaboration are based:

Pillar 1: Humility

You are not the center of the universe (nor is your code!). You’re neither omniscient nor infallible. You’re open to self-improvement.

Pillar 2: Respect

You genuinely care about others you work with. You treat them kindly and appreciate their abilities and accomplishments.

Pillar 3: Trust

You believe others are competent and will do the right thing, and you’re OK with letting them drive when appropriate.

Although it’s important to be humble, that doesn’t mean you need to be a doormat; there’s nothing wrong with self-confidence. Rather than worrying about whether you’re personally awesome, try to build a sense of team accomplishment and group pride.

In a professional software engineering environment, criticism is almost never personal—it’s usually just part of the process of making a better project.

The trick is to make sure you (and those around you) understand the difference between a constructive criticism of someone’s creative output and a flat-out assault against someone’s character. The latter is useless—it’s petty and nearly impossible to act on. The former can (and should!) be helpful and give guidance on how to improve.

And, most important, it’s imbued with respect: the person giving the constructive criticism genuinely cares about the other person and wants them to improve themselves or their work. Learn to respect your peers and give constructive criticism politely.

A better way to say the same thing might be, “Hey, I’m confused by the control flow in this section here. I wonder if the xyzzy code pattern might make this clearer and easier to maintain?” Notice how you’re using humility to make the question about you, not them. They’re not wrong; you’re just having trouble understanding the code.

Failure is viewed as a golden opportunity to learn and improve for the next go-around.

A proper postmortem should always contain an explanation of what was learned and what is going to change as a result of the learning experience.

Properly documenting failures also makes it easier for other people (present and future) to know what happened and avoid repeating history. Don’t erase your tracks—light them up like a runway for those who follow you!

A good postmortem should include the following:

  • A brief summary of the event
  • A timeline of the event, from discovery through investigation to resolution
  • The primary cause of the event
  • Impact and damage assessment
  • A set of action items (with owners) to fix the problem immediately
  • A set of action items to prevent the event from happening again
  • Lessons learned

Not true. Admitting that you’ve made a mistake or you’re simply out of your league can increase your status over the long run. In fact, the willingness to express vulnerability is an outward show of humility, it demonstrates accountability and the willingness to take responsibility, and it’s a signal that you trust others’ opinions. In return, people end up respecting your honesty and strength. Sometimes, the best thing you can do is just say, “I don’t know.”

Google eventually fixed the problem by explicitly defining a rubric for what we mean by “Googleyness”—a set of attributes and behaviors that we look for that represent strong leadership and exemplify “humility, respect, and trust”:

Thrives in ambiguity

Can deal with conflicting messages or directions, build consensus, and make progress against a problem, even when the environment is constantly shifting.

Values feedback Has humility to both receive and give feedback gracefully and understands how valuable feedback is for personal (and team) development.

Challenges status quo

Is able to set ambitious goals and pursue them even when there might be resistance or inertia from others.

Puts the user first

Has empathy and respect for users of Google’s products and pursues actions that are in their best interests.

Cares about the team

Has empathy and respect for coworkers and actively works to help them without being asked, improving team cohesion.

Does the right thing

Has a strong sense of ethics about everything they do; willing to make difficult or inconvenient decisions to protect the integrity of the team and product.

The foundation for almost any software endeavor—of almost any size—is a well-functioning team. Although the Genius Myth of the solo software developer still persists, the truth is that no one really goes it alone. For a software organization to stand the test of time, it must have a healthy culture, rooted in humility, trust, and respect that revolves around the team, rather than the individual.

Further, the creative nature of software development requires that people take risks and occasionally fail; for people to accept that failure, a healthy team environment must exist.


• Be aware of the trade-offs of working in isolation.

• Acknowledge the amount of time that you and your team spend communicating and in interpersonal conflict. A small investment in understanding personalities and working styles of yourself and others can go a long way toward improving productivity.

• If you want to work effectively with a team or a large organization, be aware of your preferred working style and that of others.