I’ve been a bit hesitant to write something about this, since I think it’s something of a delicate subject . . . it’s just a bit odd to write about, knowing that people I work with will read it. But it’s an important enough subject, and one that I feel strongly enough about, that I think it’s finally time to say something about it.
For those of you who are reading this and don’t know, my technical title is something like “PolicyCenter Architect.” Since I think the word “architect” in a software context has taken on all sorts of horrible connotations (it conjures up images of people who draw boxes and arrows but don’t actually write any code themselves), I tend not to use it personally. Instead, I tend to think of my role on the team as being the guy who should be blamed when things don’t work. Not the guy who should be blamed when something he did doesn’t work, but just the guy to blame, period.
I know it’s something of an extreme stance to take, which is why I think it’s worth an explanation. Coming at it from a different angle: my job is to make sure that the project doesn’t fail for technical reasons. If the code is buggy, or it doesn’t perform, or it’s not flexible enough or in the right ways, then I’ve failed to do my job. It doesn’t really matter why, or who wrote the code: I’m supposed to make sure that doesn’t happen, and to do whatever it takes to get there. In some ways that’s fundamentally unfair, since I can’t possibly control everything that goes on, yet I’m personally responsible for it anyway. I honestly think that’s still how it has to be.
Taking responsibility for things is a powerful thing, especially when they’re things that you don’t directly control. Part of being a professional is certainly taking responsibility for your own work, and not passing the blame to someone else when things go wrong. But I think it’s even more powerful to simply say I will not let this fail. Full stop. But I think the only way to really get to that mindset is to take responsibility for that failure; otherwise, there will always be the temptation to throw up your hands and pass the blame on to someone else, and at the moment you absolve yourself of responsibility for that failure you’re lessening your personal drive to do something about it. The other thing that needs to happen is that you have to accept the fact that things could fail, that you have limited control over that, and if they do it’ll be your fault anyway. Failure sucks, and it’s a hard thing to swallow: on my current project, it took me about five months to really come to peace with the fact that I was going to have to make a lot of very, very hard yet speculative decisions and that my best efforts could still end in failure (and a very, very costly failure at that). Once I finally did, though, I slept a lot easier, and it freed me up to do better work than I otherwise would have been able to do. Whatever role I managed to play in making the project succeed, I think it was significantly aided by the fact that I got over being afraid of screwing up.
I think there are three primary reasons why taking responsibility and blame for things you don’t actually have control over works out. First of all, it forces you to do whatever you can to minimize that chance of failure. Since you don’t have complete control, you can’t get it down to zero, but you sure have an incentive to get it there. And not only that, but you have an incentive to do what’s right for the project as a whole, not just for your part of it or for you personally. That extra drive, extra motivation, and whole-project orientation will lead to you doing more to make the project succeed than you would otherwise. Secondly, it lets you make hard decisions under uncertain conditions. A lot of projects fail simply because no one is willing to make those decisions; it’s always less personally risky to leave things as they are, or to take the well-trod route, or to pass the decision off to someone else even if they’re not in the best position to make the decision. Sometimes, you’re the best person to make the decision, and you just have to be willing to do it. Sometimes you’re not, so you have to pass the analysis off to someone else, but in order for them to really make the best decision they can they have to know that you’re going to back them up and not blame them if it goes wrong for some reason. Lastly, while I really have no idea what anyone who works with me really thinks, I like to think that having someone willing to take that level of responsibility lets everyone else on the team do better work too, since they know that someone has their back, they can focus on doing their best instead of worrying about trying to look good, and they have the freedom to do what they think is the right thing.
It’s worth mentioning that the flip side of taking the blame is not taking the credit. I’m not the first one to point out that good leaders should accept blame and deflect responsibility, but I think it’s one of those things that it’s hard to repeat enough. Never, ever take credit for other people’s work (even if you helped out), and when in doubt err on the side of taking too little (preferably way too little) credit.