I believe that I read somewhere that Google has a rule of thumb that an excellent developer is around 300 times more productive than an average one. Does anyone have any rules of thumb used by large companies or maybe there are even some empirical studies on this?

  • 2
    How do you quanitfy/measure "Excellent" and "Average"? What unit is it measured in? May 2 '11 at 21:08
  • 5
    300 times? Damn, thats a lot! I personally figured 10 times might be reasonable. But if google says 300, I'd better change my mind :) May 2 '11 at 21:11
  • 12
    Attempts to put numbers on it tend to break down due to the simple fact that an excellent developer can do things which an average one cannot - no matter how much time they are given. May 2 '11 at 21:17
  • 1
    @David: Well, my department's application is written in Java, runs on the WebSphere platform, and they use RAD to work on it. I guess I can't be as productive as possible because the tools are already chosen as corporate standard, and they're not what I would have chosen (vi, LISP, and a custom web server written in C). Bummer. :( May 2 '11 at 21:20
  • 5
    A factor of 300 basically says that the excellent programmer can do in 1 day what it takes the average programmer 1 1/2 years. In general it doesn't seem plausible that 300 is even remotely realistic. However, there are certainly software systems that an average programmer will never be able to design and get working. In that case, the productivity factor is infinite.
    – Dunk
    May 11 '11 at 16:04

Different studies have found different answers to this question, usually in the 10-fold to 100-fold range.

The one I trust most is the classic book Peopleware. They reported on a set of coding wars that they had between programmers from different companies, with the programmers in the corporate environment. They found that factor of 10 differences between developers were common. However they also found that much of the difference could be attributed to corporate environment. (Quiet working conditions, more floor space, lots of whiteboards, etc.) Their question didn't answer whether good developers gravitate towards the better corporate environment or whether the environment enables developers to produce more.

Extreme examples should be bigger than this initial range. And, of course, there is the often made observation that certain tasks can only be done by programmers who have learned certain things. For instance I would find it fairly easy to knock off a dynamic programming problem that most professional developers I've seen would never be able to figure out. That happens to be a technique that I have that they don't, and they will probably never think of it on their own. Of course lots of other programmers have that particular technique, and it is no harder for them than it is for me...

  • This is just one part of a great book that is high up on my recommended reading list. May 2 '11 at 22:35

The studies I've seen suggest a factor of ten between best and worst (measured by time taken to accomplish tasks of small or medium difficulty), and my interpretation of the data suggests this might be conservative.

It could be that the lower end degrades disproportionately fast given big, complicated, and/or innovative projects. This is only speculation, but if it does apply it might lead to a much greater differential on Google projects.

It could be that Google is measuring how many programmers are needed to do a given task in a given time. Brooks suggested that three times the number of programmers could do twice the work in a given time. This suggests that, to equal one 10, you'd need something like thirty 1s, and so you might rate a 10 as thirty times as productive as a 1. (And, yes, this implies large projects so you can get large teams up and running. I can complete a simple project in less time than it takes to introduce thirty people to each other.)

Neither of these are likely to give us a factor of 300. Suppose that, for a given type of project, an excellent programmer is forty times as good as a mediocre one, which requires that the mediocre one's effectiveness degrades four times as much. Using the "how many programmers" formula from the last paragraph, it would seem that somewhere close to three hundred floundering 1s could match a challenged 10.

This is a lot of speculation, but it would explain the 300 number. It's also possible it was misreported, or that Google's just exaggerating the difference for some reason.

  • 1
    I would be interested to see those studies. Do you have a reference?
    – David
    May 2 '11 at 21:47
  • @David: Specifically, de Marco and Lister's book "Peopleware", and a "Hitting the High Notes" column in Joel on Software. May 2 '11 at 21:49
  • you're probably right about the difficulties that are/were specific to google - large, distributed systems were relatively rare before and Google no doubt struggled to find programmers who could understand the requirements.
    – Мסž
    May 3 '11 at 2:26

I don't see how you could even put a ball park figure to such a comparison. There just too many factors involve including the environment (physical and development) the engineers are working in, the team that the engineers are working with, the type of problems to be solved etc....and there is also the question of how productivity is measured.


It's hard to say and based one a lot of uncertain terms, how efficient is the "average" programmer, how fast is an "excellent" programmer?

300 does seem a bit high though, I'd go more in the 50-100 times range.

The main thing I think people underestimate with programming is that it's not only the actual skill. An excellent programmer will have build up libraries and tools. Obviously if I just have to dip into my library to fetch out something I've already done and you have to spend a month coding it, I will be extremely more efficient.

If I've built code generating tools where I can just write a configuration file and press a button to generate a bunch of classes where you have a couple of days coding the classes, of course I'm going to be extremely more efficient.

That being said, never think you've reached your peak as a programmer. I find that programmers are like Moore's law, they double in effiency every two years :)

Sharpen your saws gentlemen


It's certainly not a linear scale. I do believe a good developer (strong SOLID OO) is much more worth the money than average developers - but it depends on what the client needs. If the code is likely to be changing or reusable in the future - then definitely get 1 strong (and expensive) developer. If the code is short term and will be disposed off ... get a few copy&paste / spaghetti developers. [13yrs experience as OO developer]


Millions (hundreds of millions perphaps) of people play soccer, yet very few can score a goal in the semifinal of the world cup. You need to remember that excellent developers are few, and they practice their mental skills relentlessly, always improving, always sharpening them. Indeed, in the coder's world cup, they score the goals on demand, under very high pressure, keeping their cool.

-- This Rah-Rah Was Brought To You By The Church of Programming. Code Contributions Welcome!

Not the answer you're looking for? Browse other questions tagged or ask your own question.