Programmer Competency Matrix – 32 attributes to evaluate programmers

Having worked with programmers with an extreme variance in skills, I sometimes get the feeling that there is an big lack of good programmers but when I thought about it a little more I realized that it’s not very clear cut, some of the programmers have strong areas and if you confine the tasks into their strong areas then they tend to deliver well. So I started thinking about all the lines on which we can evaluate a programmer, here’s what I have so far…

Programmer Competency Matrix (the table is too big to fit on this blog post and needs a whole page of it’s own)

After having spent a whole afternoon on this I realize that even this is not comprehensive, this matrix is more biased towards non-visual programmers, so a big majority of web devs will not be able to relate well to this matrix, but I am tired and will come back to this at a later time.


  1. Well done excellent table and I will use this to gauge my skills as a developer so far I’m primarily in Level 1 and Level 2. :(. But this is definitely a step in the right direction so now I know what I have to learn and aim for. Even though this isn’t official it’s good in my book.

  2. Great job! This might come in handy to rate programmers after a job interview. Personally I still have some catchup to do 🙂

  3. Excellent way of breaking down observations. I am not sure how other are, but I am all over the levels randing from 1 to 3 on all aspects. Atleast I’m not at Level 0 – phew!

  4. Brilliant table. Covers the bases nicely. Nice way of summing up the important differences between the stages of expertise.

  5. Hi, thank you for the matrix its a useful tool to gauge strengths and weaknesses. I was wondering how much a programmer that is at 95% on Level2 and 50% level 3 would on average be expected to earn in a profitable and innovative company in the United States.

  6. I especially like that the table focuses on areas of competence that are relevant no matter if you work on GUI, middleware, database, batchjobs, soft realtime, mobile etc.

    The “automated testing” row could be improved by level 2 being “used TDD regularly” and level 3 being “knows why TDD is a most often a bad idea” 😉

    Also I missed coverage of ability to work with customers, bosses, and specialists in other fields than software.

  7. Great work. I will definately use it.

    I found some errors in “languages exposed to”:

    – SQL does not strike me as a declarative language.
    – Imperative and object oriented are orthogonal. You can have languages that are both, neither and just one of the two.

    – Java is an imperative, object oriented language.
    – Haskell is not imperative, but object oriented.
    – xslt is not imperative and not object oriented.
    – Most older versions of Basic are imperative and not object oriented.

    AFAIK the most common language classes (that are usually mutually exclusive) are imperative, declarative and functional. Some would add logic programming, but thats usually contained in the class of declarative languages.

  8. Hi, sorry to post again, but just wondering if you would post what your estimate would be on how much a programmer would be expected to earn at the level indicated above, which would be a conservative estimate (at least that much experience, I know it would be dependant upon geography, which I could use a service like payscale to equate to other areas). Thank you, Glad to see your site is back online….

  9. two minor suggestions:

    link back to this page from the matrix

    add “Array (APL, J, MATLAB)” to the log(n) column of the two language rows

  10. The guy that wrote the matrix hasn’t enough experience to be able to determine what people need to know. When I compare my 28 years of professional experience to his 7 or so years, I find that from a managerial standpoint (I’m a senior consultant and technical manager for a Fortune 400 company which means I review code, write designs, and mentor developers) there are a lot of things missing from that table, and a lot of things that matter not at all.

    (For the record, I’ve written code for 737 flight trainers, show control software in Las Vegas hotels, and pioneered hardware and software products that changed the face of the travel industry. I even wrote a few games back in the late 80’s.)

    What the writer fails to perceive is that it isn’t what you know, it’s what you do with the knowledge. We’ve certainly had to fire programmers that would have ranked in the O log(n) columns for many categories simply because they couldn’t get anything done. (I work for a rather large multi-national corporation that produces both hardware and software.) We gave one guy a project and three weeks later there wasn’t one line of code. The analysis and design was done, mind you–he was still cogitating on the relative merits of for() vs. while() vs. do-while(). In a world where payment rightfully comes from results, getting results is important–as opposed to whether or not one has “tried out Bzr/Mercurial/Darcs/Git.”

    We also have a lot of bright third-column guys that simply spend too much time screwing off instead of getting work done. Work ethic isn’t discussed at all in the matrix, and it’s actually more important than whether or not someone compiles from the IDE or on the command line.

    The matrix also doesn’t really address communications at all–it just sort of takes a lazy swipe at it and then goes back to lazy crap like “who knows the most keyboard shortcuts.” Honestly, the whole thing is so grade six that it’s embarrassing.

    As an exercise in mental masturbation, I give it a B+. As a reflection of real-world skill requirements, I give it a C-, if not a D+. The author, 20 years from now, will find it an embarrassment and hope no one downloaded and kept a copy.

  11. Hi James,

    Thanks for your inputs, This post was written a year back and I already think that some of the stuff in here is obsolete or needs revision. I can only write based on the experience that I have right now and hopefully a few years from now I can come up with a better matrix that covers more of the “getting things done” aspects that you talk about (which I agree are very important as well)

  12. This appeared to be a Microsoft Technologies Competency Matrix. Reading SICP or the Little Schemer does not get you to level 3 in the other crowd. SICP is introductory material.

    – Is able to effectively communicate with peers – is a Level 2 skill?
    – Writing a framework means little; Most “Architects” i have seen have written one. Mostly unusable.
    – File has license header, summary, well commented, consistent white space usage. The file should look beautiful?
    – Scott Hanselman’s Power Tools list?
    – ….

    I guess the list is partly valid within the Microsoft-Technology + IT Services context.

  13. I like the idea of the competency matrix and I think it could be very useful. There are a few topics I would add to the matrix somewhere. I know some of these are more from a software project management perspective, and I don’t know if you had intended to capture that in your matrix. However, since some people are going to want to use this matrix in order to gain the skills to climb up the ladder, adding software project management to the list of skills could be useful.

    Software process, lifecycles, process improvement (e.g. agile, XP, SCRUM, RUP, TSP, CMMI). Software architecture documentation (e.g. UML notations, component-and-connector diagrams). Software architecture and design (e.g. design patterns, architectural styles). Formal methods (OCL, Z, Petri Nets, rate monotonic analysis). Static analysis. Software project estimation (use case points, function points, COCOMO). Requirements documentation (use cases, user stories, quality attributes and quality attribute scenarios, paper prototypes). Project planning and management (work breakdown structures, earned value analysis). Risk management.

  14. James Hawk III, thank you for your comment on this!

  15. Regarding James Hawk III’s comments – I think these are a unnecessary viscous (and probably shows someones belief in their own self importance). I’ve been developing real-time embedded systems for both military and commercial systems since the mid-1980’s (and no I haven’t “changed the face” of those). Yes I agree that maybe the chart is based more on knowledge rather than competency (competency – the proven ability to use knowledge, skills and other abilities to perform a function against a given standard in work), but this is very common confusion (see Microsoft MCSE etc.). The other thing that could be improved is clarifying the target domain (many of the things there aren’t applicable to real-time embedded systems) – e.g. what type of applications. I worry about James’ managerial style if doesn’t understand the basics of constructive feedback – let’s see your attempt then? Overall it’s a good first attempt and gives a useful vehicle for discussion (as per Sam’s feedback).

  16. I don’t really agree with the way this is setup. You should really get down to the essentials of programming. You mention books like Code Complete, yet you fail to take it’s advice (traits of a good programmer). Traits are way more important than tool or even language knowledge. Communication is one. Depending on the situation (programming games, space shuttles, web apps, bookkeeping) influences what you need to know. Knowing a gazillion languages doesn’t help in a project if you’re working in only one. Patterns should emerge out of good design and common sense, not memorized etc. And I am not putting it down because I don’t understand the matrix, I do. Most modern languages used nowadays are imperative OO (Java, PHP, .NET) so it would help to master at least that.

  17. The problem with this whole thing is the lack of #ux (user experience and usability). All the points made are moot if you’re building /the wrong product/.

    Some other things to point out:
    DVCS: lacking for the level of knowledge needed at a “log n” level. Rebasing with GIT or scripting something in SVN to act like GIT’s bisect functionality.
    also missing. ability to work with branch-per-feature, merging strategies, VCS hooks and custom attributes.
    architecture part is missing. No mention of DDD or description of where OO came from and why
    IoC, DI, the rest of SOLID. AOP
    where to use and where not to use
    where and why RAD is good / bad
    IDE is very shortsighted making custom macros look like a holy grail. Refactoring tools like IntelliJ IDEA, Resharper, Refactor Pro, Code Rush?

    Just initial thoughts, I tweeted the same thing but may have left something out.

    Otherwise, a great place to start discussion.


  18. That is a helpful programmer competency matrix. I would like to set this up as a goal to move as close to level 2 as possible in about a year. Perhaps mentors should show this matrix to beginners and give them a rough idea about what they should do to become better programmers.

    I found a similar matrix created by an organization. You can find it on my blog at

  19. The Database knowledge row is woefully inadequate. Programmers a step above 2^n, your n^2 level, generally have no idea what ACID stands for, let alone anything further up the chart. n^2 should be “Basic competence in SQL. Can design tables for simple task. Has heard of Indexes.” Then shift the exist n^2 and n right one place. Parts of level logn reads more like a DBA job description than a programmer competence description and doesn’t belong on the chart.

    Similarly, you 2^n blob level is wrong too. Most low-competency programmers have no idea there are programming blogs. I know some folks who hit logn status in parts of your matrix who would respond “Really? There are programming blogs?” if asked what they read.

  20. This is the single most motivating thing I’ve seen in – well I can’t even remember how much. Thank you.

    The only point I’d strongly disagree with is deep API usage knowledge. The whole point of APIs is to just take them as you go, when you need them, in a no-brainer way – hence all the authors’ efforts on naming, parameters, functionality description, local organization into packages… Browsing the source of the Java class library is much more worthy of one’s time than memorizing a bunch of method signatures.

6 Trackbacks

  1. matrix 4 (Pingback)
  2. sides of march - What’s your Programmer Competency? (Pingback)
  3. Diario de Programación » Blog Archive » Un par de tablas interesantes (Pingback)
  4. Programmer Competency Matrix « Angel “Java” Lopez on Blog (Pingback)
  5. Matriz de Competencias de Programación - Angel "Java" Lopez (Pingback)
  6. Matriz de Competencias de Programación | Buanzolandia (Pingback)